hpconvert.java

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

        }
        return v;
    }//end of function Chr


    public static Variant CHR(boolean expression) throws HpException
    {
        return new VString( CHR$(expression) );
    }

    public static Variant CHR(HByte expression) throws HpException
    {
        return new VString( CHR$(expression) );
    }

    public static Variant CHR(short expression) throws HpException
    {
        return new VString( CHR$(expression) );
    }

    public static Variant CHR(int expression) throws HpException
    {
        return new VString( CHR$(expression) );
    }

    public static Variant CHR(float expression) throws HpException
    {
        return new VString( CHR$(expression) );
    }

    public static Variant CHR(double expression) throws HpException
    {
        return new VString( CHR$(expression) );
    }

    public static Variant CHR(HCurr expression) throws HpException
    {
        return new VString( CHR$(expression) );
    }

    public static Variant CHR(HDate expression) throws HpException
    {
        return new VString( CHR$(expression) );
    }

    public static Variant CHR(fixedString expression) throws HpException
    {
        return new VString( CHR$(expression) );
    }

    public static Variant CHR(String expression) throws HpException
    {
        return new VString( CHR$(expression) );
    }


    public static Variant CHRB(Variant varnumber) throws HpException
    {
        return CHR( varnumber ) ;
    }

    public static Variant CHRB(boolean expression) throws HpException
    {
        return new VString( CHR$(expression) );
    }

    public static Variant CHRB(HByte expression) throws HpException
    {
        return new VString( CHR$(expression) );
    }

    public static Variant CHRB(short expression) throws HpException
    {
        return new VString( CHR$(expression) );
    }

    public static Variant CHRB(int expression) throws HpException
    {
        return new VString( CHR$(expression) );
    }

    public static Variant CHRB(float expression) throws HpException
    {
        return new VString( CHR$(expression) );
    }

    public static Variant CHRB(double expression) throws HpException
    {
        return new VString( CHR$(expression) );
    }

    public static Variant CHRB(HCurr expression) throws HpException
    {
        return new VString( CHR$(expression) );
    }

    public static Variant CHRB(HDate expression) throws HpException
    {
        return new VString( CHR$(expression) );
    }

    public static Variant CHRB(fixedString expression) throws HpException
    {
        return new VString( CHR$(expression) );
    }

    public static Variant CHRB(String expression) throws HpException
    {
        return new VString( CHR$(expression) );
    }


    public static String CHRB$(Variant expression) throws HpException
    {
        return CHR$( expression);
    }

    public static String CHRB$(boolean expression) throws HpException
    {
        return CHR$( expression);
    }

    public static String CHRB$(HByte expression) throws HpException
    {
        return CHR$( expression);
    }
    public static String CHRB$(short expression) throws HpException
    {
        return CHR$( expression);
    }
    public static String CHRB$(int expression) throws HpException
    {
        return CHR$( expression);
    }
    public static String CHRB$(float expression) throws HpException
    {
        return CHR$( expression);
    }

    public static String CHRB$(double expression) throws HpException
    {
        return CHR$( expression);
    }

    public static String CHRB$(HCurr expression) throws HpException
    {
        return CHR$( expression);
    }

    public static String CHRB$(HDate expression) throws HpException
    {
        return CHR$( expression);
    }
    public static String CHRB$(fixedString expression) throws HpException
    {
        return CHR$( expression);
    }
    public static String CHRB$(String expression) throws HpException
    {
        return CHR$( expression);
    }

    public static Variant CHRW(Variant varnumber) throws HpException
    {
        return  CHR(varnumber);
    }//2


    public static Variant CHRW(boolean expression) throws HpException
    {
        return new VString( CHR$(expression) );
    }

    public static Variant CHRW(HByte expression) throws HpException
    {
        return new VString( CHR$(expression) );
    }

    public static Variant CHRW(short expression) throws HpException
    {
        return new VString( CHR$(expression) );
    }

    public static Variant CHRW(int expression) throws HpException
    {
        return new VString( CHR$(expression) );
    }

    public static Variant CHRW(float expression) throws HpException
    {
        return new VString( CHR$(expression) );
    }

    public static Variant CHRW(double expression) throws HpException
    {
        return new VString( CHR$(expression) );
    }

    public static Variant CHRW(HCurr expression) throws HpException
    {
        return new VString( CHR$(expression) );
    }

    public static Variant CHRW(HDate expression) throws HpException
    {
        return new VString( CHR$(expression) );
    }

    public static Variant CHRW(fixedString expression) throws HpException
    {
        return new VString( CHR$(expression) );
    }

    public static Variant CHRW(String expression) throws HpException
    {
        return new VString( CHR$(expression) );
    }


    /**
	 *Hex(number)
	 *Returns a string representing the hexadecimal value of a number.
	 *if number = Null return Null.if number = Empty return	Zero (0). if number is
	 *Any other number	Up to eight hexadecimal characters.
	 */
    public static String HEX$( Variant expression) throws HpException
    {
        double d = hpstring.get_db(expression);
        int number = hpstring.dbl2int(d);
        if( (expression.getType()==Variant.V_INT || expression.getType()==Variant.V_BOL)
            && (number<0 && number>=-32768 ) )
            number = 65535 + number+1;

        return  Integer.toHexString(number).toUpperCase();
    }

    public static String HEX$(boolean expression) throws HpException
    {
        int number = expression==true ? -1:0;
        if(number==-1)
            number = 65535 + number + 1;
        return Integer.toHexString(number).toUpperCase();
    }
    public static String HEX$(HByte expression) throws HpException
    {
        return Integer.toHexString((int)(expression.byteValue() )).toUpperCase();
    }
    public static String HEX$(short expression) throws HpException
    {
        int number=(int) expression;
        if (number<0 && number>=-32768)
            number = 65535 + number + 1;
        return Integer.toHexString(number).toUpperCase();
    }
    public static String HEX$(int expression) throws HpException
    {
        return Integer.toHexString(expression).toUpperCase();
    }
    public static String HEX$(float expression) throws HpException
    {
        int number = hpstring.dbl2int((double)expression);
        return Integer.toHexString(number).toUpperCase();
    }
    public static String HEX$(double expression) throws HpException
    {
        int number = hpstring.dbl2int(expression);
        return Integer.toHexString(number).toUpperCase();
    }
    public static String HEX$(HCurr expression) throws HpException
    {
        int number = hpstring.dbl2int(expression.dblValue() );
        return Integer.toHexString(number).toUpperCase();
    }
    public static String HEX$(HDate expression) throws HpException
    {
        int number = hpstring.dbl2int( expression.dblValue() );
        return Integer.toHexString(number).toUpperCase();
    }
    public static String HEX$(fixedString expression) throws HpException
    {
		String  str = expression.strValue();

        double d = hpstring.strtodbl( str);
        int number = hpstring.dbl2int(d);

        return Integer.toHexString(number).toUpperCase();
    }

    public static String HEX$(String expression) throws HpException
    {
        double d = hpstring.strtodbl( expression);
        int number = hpstring.dbl2int(d);
        return Integer.toHexString(number).toUpperCase();
    }

    public static Variant HEX(Variant varnum) throws HpException
    {
        String      hexstr;
        int         number=0;
        Variant     v = null;

        int type = varnum.getType();
        if( type==Variant.V_NULL )
        {
            v = new VNull();
        }
        else
        {
            double d = hpstring.get_db(varnum);
            number = hpstring.dbl2int(d);
            if( (type==Variant.V_INT || type==Variant.V_BOL)
                && (number<0 && number>=-32768 )           )
                number = 65535 + number+1;

            hexstr = Integer.toHexString(number).toUpperCase();
            v = new VString( hexstr );
        }
        return v;
    } //end of function HEX

    public static Variant HEX(boolean expression) throws HpException
    {
        return new VString(HEX$(expression));
    }
    public static Variant HEX(HByte expression) throws HpException
    {
        return new VString(HEX$(expression));
    }
    public static Variant HEX(short expression) throws HpException
    {
        return new VString(HEX$(expression));
    }
    public static Variant HEX(int expression) throws HpException
    {
        return new VString(HEX$(expression));
    }
    public static Variant HEX(float expression) throws HpException
    {
        return new VString(HEX$(expression));
    }
    public static Variant HEX(double expression) throws HpException
    {
        return new VString(HEX$(expression));
    }
    public static Variant HEX(HCurr expression) throws HpException
    {
        return new VString(HEX$(expression));
    }
    public static Variant HEX(HDate expression) throws HpException
    {
        return new VString(HEX$(expression));
    }
    public static Variant HEX(fixedString expression) throws HpException
    {
        return new VString(HEX$(expression));
    }

    public static Variant HEX(String expression) throws HpException
    {
        return new VString(HEX$(expression));
    }


    /**
	 *Oct(number)
	 *The number argument is any valid numeric or string expression.
	 *if number = Null return Null.if number=Empty return Zero (0). if number is Any
	 *other number return Up to 11 octal characters.
	 */
    public static String OCT$(Variant expression ) throws HpException
    {
        int     number = hpstring.dbl2int( expression.dblValue() );
        if( (expression.getType()==Variant.V_INT || expression.getType()==Variant.V_BOL )
            && (number<0 && number>=-32768 ) )
            number = 65535 + number+1;

        return Integer.toOctalString(number).toUpperCase();
    }

    public static String OCT$( boolean expression) throws HpException
    {
        int  number = expression==true ? -1:0;
        if( number==-1)
            number = 65535 + number+1;

        return Integer.toOctalString(number).toUpperCase();
    }
    public static String OCT$(HByte expression) throws HpException
    {
        return Integer.toOctalString((int)(expression.byteValue())).toUpperCase();
    }
    public static String OCT$(short expression) throws HpException
    {
        int   number = (int)expression;

        if(number<0 && number>=-32768 )
            number = 65535 + number+1;
        return Integer.toOctalString((int)number).toUpperCase();
    }
    public static String OCT$(int expression) throws HpException
    {
        return Integer.toOctalString(expression).toUpperCase();
    }
    public static String OCT$(float expression) throws HpException
    {
        int    number = hpstring.dbl2int( (double)expression );
        return Integer.toOctalString(number).toUpperCase();
    }
    public static String OCT$(double expression) throws HpException
    {
        int number = hpstring.dbl2int( expression );
        return Integer.toOctalString(number).toUpperCase();
    }
    public static String OCT$(HCurr expression) throws HpException
    {
        int number = hpstring.dbl2int( expression.dblValue() );
        return Integer.toOctalString(number).toUpperCase();
    }
    public static String OCT$(HDate expression) throws HpException
    {
        int number = hpstring.dbl2int( expression.dblValue() );
        return Integer.toOctalString(number).toUpperCase();
    }
    public static String OCT$(fixedString expression) throws HpException
    {
        String s = expression.strValue();
        int number = hpstring.dbl2int( hpstring.strtodbl(s) );
        return Integer.toOctalString(number).toUpperCase();
    }
    public static String OCT$(String expression) throws HpException
    {
        double d = hpstring.strtodbl(expression);
        int number = hpstring.dbl2int( d );
        return Integer.toOctalString(number).toUpperCase();
    }

    public static Variant OCT(Variant varnum ) throws HpException
    {
        int     number=0;
        String  octstr;
        Variant  v = null;

        int type = varnum.getType();
        if( type==Variant.V_NULL )
        {
            v = new VNull();
        }
        else
        {
            number = hpstring.dbl2int( varnum.dblValue() );
            if( (type==Variant.V_INT || type==Variant.V_BOL ) &&
                (number<0 && number>=-32768 ) )
                number = 65535 + number+1;

            octstr = Integer.toOctalString(number).toUpperCase();
            v = new VString(octstr);
        }
        return v;
    }

    public static Variant OCT( boolean expression) throws HpException
    {
        return new VString( OCT$(expression) );
    }
    public static Variant OCT(HByte expression) throws HpException
    {
        return new VString( OCT$(expression) );
    }
    public static Variant OCT(short expression) throws HpException
    {
        return new VString( OCT$(expression) );
    }
    public static Variant OCT(int expression) throws HpException
    {
        return new VString( OCT$(expression) );
    }
    public static Variant OCT(float expression) throws HpException
    {
        return new VString( OCT$(expression) );
    }
    public static Variant OCT(double expression) throws HpException