Winape - feature request

[Gryzor]

Hello!
Yesterday I was loading some dsk's and I realised, it would be really nice if Winape could detect whether it's running or not and NOT launch a second instance when the user double-clicks a second disk image... you think it's easy to implement?

[McKlain]

I would like a disk-browser like the one on WinVICE 

[Gryzor]

Oh wow, this is really great indeed!!!

[Devilmarkus]

JavaCPC has something similar:

Menu: File -> Drives -> DF0/DF1 -> File inspector



Perhaps I am able to combine that with a file dialogbox... Need to check that...

[Gryzor]

Ah yes, I've used that. I thin WinVICE's implementation is better, since it shows you everything when you just single-click on a file, in the Open dialog. Very elegant.

[Devilmarkus]

Well in JavaCPC's case the file inspector is just a "waste product" or byproduct, which I used when I tested some "Grab DIR" functions.

Also the scientific calculator is a byproduct I coded to check the math parser...

But should I delete both?
No, because some people perhaps find it useful

[Gryzor]

No, of course not, are you kidding? (well, maybe the sci calc )

[TFM]

I would like to have the calc on the CPC ,-)

[Devilmarkus]

I would like to have the calc on the CPC ,-)

Sure here you go:

Code Select Expand

/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package jemu.util.ass;

/**
* Title:        JavaCPC
* Description:  The Java Amstrad CPC Emulator
* Copyright:    Copyright (c) 2006-2010
* Company:
* @author
* @version 6.8
*/
import java.util.Stack;

public class Parser {

    private static double result;
    public static boolean precision = false;
    public static boolean DEG;
    public static boolean RAD;

    public Parser(String expression) throws Exception {
        expression = analyseExpressionForSymbols(expression);
        result = calculatePostFix(generatePostFix(expression));
    }

    public static String Format(String in) {
        if (in.contains(" AND ")) {
            in = in.replace(" AND ", " | ");
        }
        if (in.contains(" OR ")) {
            in = in.replace(" OR ", " ¡ ");
        }
        if (in.contains(" XOR ")) {
            in = in.replace(" XOR ", " ! ");
        }
        if (in.contains(" and ")) {
            in = in.replace(" and ", " | ");
        }
        if (in.contains(" or ")) {
            in = in.replace(" or ", " ¡ ");
        }
        if (in.contains(" xor ")) {
            in = in.replace(" xor ", " ! ");
        }
        in = in.replace(" ", "");
        return in;
    }

    public static String parseMath(String expression) {
        String out = expression;
//        System.out.print("Input is: " + expression);
        expression = Format(expression);
        try {
            DEG = false;
            RAD = true;
            expression = expression.replace("²", "^2");
            expression = expression.replace("³", "^3");
            if (expression.startsWith("deg:")) {
                DEG = true;
                RAD = false;
                expression = expression.substring(4);
            }
            if (expression.startsWith("rad:")) {
                DEG = false;
                RAD = true;
                expression = expression.substring(4);
            }
            if (expression.startsWith("grad:")) {
                DEG = false;
                RAD = false;
                expression = expression.substring(5);
            }
            expression = analyseExpressionForSymbols(expression);
            result = calculatePostFix(generatePostFix(expression));
//        System.out.println(" Parsed is: " + expression);
            return "" + (int) result;
        } catch (Exception e) {
            return null;
        }
    }

    public static String parseMaths(String expression) {
        expression = Format(expression);
        try {
            DEG = false;
            RAD = true;
            expression = expression.replace("²", "^2");
            expression = expression.replace("³", "^3");
            if (expression.startsWith("deg:")) {
                DEG = true;
                RAD = false;
                expression = expression.substring(4);
            }
            if (expression.startsWith("rad:")) {
                DEG = false;
                RAD = true;
                expression = expression.substring(4);
            }
            if (expression.startsWith("grad:")) {
                DEG = false;
                RAD = false;
                expression = expression.substring(5);
            }
//            System.err.println("Input:" + expression);
            boolean prec = precision;
            precision = true;
            expression = analyseExpressionForSymbols(expression);
            result = calculatePostFix(generatePostFix(expression));
            precision = prec;
            return "" + result;
        } catch (Exception e) {
            return "";
        }
    }

    public static String parseMath(String expression, boolean preci, boolean hex) {
        expression = Format(expression);
        try {
            DEG = false;
            RAD = true;
            expression = expression.replace("²", "^2");
            expression = expression.replace("³", "^3");
            if (expression.startsWith("deg:")) {
                DEG = true;
                RAD = false;
                expression = expression.substring(4);
            }
            if (expression.startsWith("rad:")) {
                DEG = false;
                RAD = true;
                expression = expression.substring(4);
            }
            if (expression.startsWith("grad:")) {
                DEG = false;
                RAD = false;
                expression = expression.substring(5);
            }
//            System.err.println("Input:" + expression);
            boolean prec = precision;
            precision = preci;
            expression = analyseExpressionForSymbols(expression);
            result = calculatePostFix(generatePostFix(expression));
            precision = prec;
            if (hex) {
                return "" + (int) result;
            } else {
                return "" + result;
            }
        } catch (Exception e) {
            return "";
        }
    }

    private static String analyseExpressionForSymbols(String expression) throws Exception {
        expression = Format(expression);
        expression = "(" + expression + ")";
        if (findAdequateBracketEnd(expression, 0) == -1) {
            throw new Exception("Brackets are set wrongly");
        }
        expression = transformMinus(expression);
        expression = transformSqrt(expression);
        expression = transformExp(expression);
        expression = transformPi(expression);
        expression = transformSqr(expression);
        expression = transformTrigo(expression, "");
        return expression;
    }

    private static int findAdequateBracketEnd(String expression, int start) {
        expression = Format(expression);
        int count = 0;
        for (int i = start; i < expression.length(); i++) {
            if (expression.charAt(i) == '(') {
                count++;
            } else {
                if (expression.charAt(i) == ')') {
                    count--;
                    if (count == 0) {
                        return i;
                    }
                }
            }
        }
        return count == 0 ? expression.length() - 1 : -1;
    }

    private static String transformTrigo(String expression, String fun) throws Exception {
        if (precision) {
            while (expression.contains("sin") || expression.contains("cos") || expression.contains("tan")) {
                int startCos = expression.indexOf("cos");
                int startSin = expression.indexOf("sin");
                int startTan = expression.indexOf("tan");
                if (startCos != -1 && ((startSin != -1 && startTan != -1 && startCos < startTan && startCos < startSin) || (startSin != -1 && startTan == -1 && startCos < startSin) || (startSin == -1 && startTan != -1 && startCos < startTan) || (startTan == -1 && startSin == -1))) {
                    int bracketEnd = findAdequateBracketEnd(expression, startCos + 3);
                    expression = expression.substring(0, startCos) + transformTrigo(expression.substring(startCos + 3, bracketEnd + 1), "cos") + expression.substring(bracketEnd + 1);
                } else {
                    if (startSin != -1 && ((startCos != -1 && startTan != -1 && startSin < startTan && startSin < startCos) || (startCos != -1 && startTan == -1 && startSin < startCos) || (startCos == -1 && startTan != -1 && startSin < startTan) || (startCos == -1 && startTan == -1))) {
                        int bracketEnd = findAdequateBracketEnd(expression, startSin + 3);
                        expression = expression.substring(0, startSin) + transformTrigo(expression.substring(startSin + 3, bracketEnd + 1), "sin") + expression.substring(bracketEnd + 1);
                    } else {
                        if (startTan != -1 && ((startSin != -1 && startCos != -1 && startTan < startSin && startTan < startCos) || (startSin != -1 && startCos == -1 && startTan < startSin) || (startSin == -1 && startCos != -1 && startTan < startCos) || (startCos == -1 && startSin == -1))) {
                            int bracketEnd = findAdequateBracketEnd(expression, startTan + 3);
                            expression = expression.substring(0, startTan) + transformTrigo(expression.substring(startTan + 3, bracketEnd + 1), "tan") + expression.substring(bracketEnd + 1);
                        }
                    }
                }
            }
            if (fun.equals("sin")) {
                if (RAD) {
                    expression = transformMinus("(" + Math.sin(Math.toRadians(calculatePostFix(generatePostFix(expression)))) + ")");
                } else if (DEG) {
                    expression = transformMinus("(" + Math.sin(Math.toDegrees(calculatePostFix(generatePostFix(expression)))) + ")");
                } else {
                    expression = transformMinus("(" + Math.sin((calculatePostFix(generatePostFix(expression)))) + ")");
                }
            } else {
                if (fun.equals("cos")) {
                    if (RAD) {
                        expression = transformMinus("(" + Math.cos(Math.toRadians(calculatePostFix(generatePostFix(expression)))) + ")");
                    } else if (DEG) {
                        expression = transformMinus("(" + Math.cos(Math.toDegrees(calculatePostFix(generatePostFix(expression)))) + ")");
                    } else {
                        expression = transformMinus("(" + Math.cos((calculatePostFix(generatePostFix(expression)))) + ")");
                    }
                } else {
                    if (fun.equals("tan")) {
                        if (RAD) {
                            expression = transformMinus("(" + Math.tan(Math.toRadians(calculatePostFix(generatePostFix(expression)))) + ")");
                        } else if (DEG) {
                            expression = transformMinus("(" + Math.tan(Math.toDegrees(calculatePostFix(generatePostFix(expression)))) + ")");
                        } else {
                            expression = transformMinus("(" + Math.tan((calculatePostFix(generatePostFix(expression)))) + ")");
                        }
                    }
                }
            }
        }
        return expression;
    }

    private static String transformSqr(String expression) {
        if (precision) {
            int pos0 = 0, pos1 = 0;
            while (expression.contains("sqr")) {
                pos0 = expression.indexOf("sqr");
                pos1 = findAdequateBracketEnd(expression, pos0 + 3);
                expression = expression.substring(0, pos0) + expression.substring(pos0 + 3, pos1 + 1) + "^2" + expression.substring(pos1 + 1);
            }
        }
        return expression;
    }

    private static String transformExp(String expression) {
        if (precision) {
            expression = expression.replace("e", "" + Math.E);
        }
        return expression;
    }

    private static String transformPi(String expression) {
        expression = expression.replace("pi", "" + Math.PI);
        expression = expression.replace("" + (char) 960, "" + Math.PI);
        return expression;
    }

    private static String transformSqrt(String expression) {
        int pos0 = 0, pos1 = 0;
        while (expression.contains("sqrt")) {
            pos0 = expression.indexOf("sqrt");
            pos1 = findAdequateBracketEnd(expression, pos0 + 4);
            expression = expression.substring(0, pos0) + expression.substring(pos0 + 4, pos1 + 1) + "^0.5" + expression.substring(pos1 + 1);
        }
        return expression;
    }

    private static String transformMinus(String expression) {
        int pos0 = 0;
        for (int i = 0; i < expression.length(); i++) {
            if (expression.charAt(i) == '-' && expression.charAt(i - 1) == '(') {
                pos0 = findAdequateBracketEnd(expression, i - 1);
                expression = expression.substring(0, i) + "(0-" + expression.substring(i + 1, pos0) + ")" + expression.substring(pos0);
            } else {
                if (expression.charAt(i) == '-' && (expression.charAt(i - 1) == '¡' || expression.charAt(i - 1) == '!' || expression.charAt(i - 1) == '|' || expression.charAt(i - 1) == '+' || expression.charAt(i - 1) == '-' || expression.charAt(i - 1) == '/' || expression.charAt(i - 1) == '*' || expression.charAt(i - 1) == '^')) {
                    for (int j = i + 1; j < expression.length(); j++) {
                        if (j == expression.length() - 1 || expression.charAt(j) == '/' || expression.charAt(j) == '*' || expression.charAt(j) == '+' || expression.charAt(j) == '¡' || expression.charAt(j) == '!' || expression.charAt(j) == '|' || expression.charAt(j) == '-' || expression.charAt(j) == '^' || expression.charAt(j) == ')') {
                            if (j == expression.length() - 1) {
                                pos0 = j + 1;
                                break;
                            } else {
                                pos0 = j;
                                break;
                            }

                        }
                    }
                    expression = expression.substring(0, i) + "(0-" + expression.substring(i + 1, pos0) + ")" + expression.substring(pos0);
                }
            }

        }
        return expression;
    }

    public static Stack<String> generatePostFix(String expression) throws Exception {
        Stack<String> operandStack = new Stack<String>();
        Stack<String> operatorStack = new Stack<String>();
        String number = "";
        int i = 0;
        operatorStack.push("(");
        try {
            while (!operatorStack.isEmpty()) {
                switch (expression.charAt(i)) {
                    case '(':
                        operatorStack.push("(");
                        break;
                    case '^':
                        operatorStack.push("^");
                        break;
                    case '|':
                        operatorStack.push("|");
                        break;
                    case '!':
                        operatorStack.push("!");
                        break;
                    case '¡':
                        operatorStack.push("¡");
                        break;
                    case '*':
                        if (precision && operatorStack.peek().matches("[^*/]")) {
                            while (!operatorStack.peek().equals("(") && (operatorStack.peek().matches("[^*/]"))) {
                                operandStack.push(operatorStack.pop() + "");
                            }
                        } else if (!precision) {
                            while (!operatorStack.peek().equals("(")) {
                                operandStack.push(operatorStack.pop() + "");
                            }
                        }
                        operatorStack.push("*");
                        break;
                    case '/':
                        if (precision && operatorStack.peek().matches("[^*/]")) {
                            while (!operatorStack.peek().equals("(") && (operatorStack.peek().matches("[^*/]"))) {
                                operandStack.push(operatorStack.pop() + "");
                            }
                        } else if (!precision) {
                            while (!operatorStack.peek().equals("(")) {
                                operandStack.push(operatorStack.pop() + "");
                            }
                        }
                        operatorStack.push("/");
                        break;
                    case '-':
                        while (!operatorStack.peek().equals("(")) {
                            operandStack.push(operatorStack.pop() + "");
                        }
                        operatorStack.push("-");
                        break;
                    case '+':
                        while (!operatorStack.peek().equals("(")) {
                            operandStack.push(operatorStack.pop() + "");
                        }
                        operatorStack.push("+");
                        break;
                    case ')':
                        String operator = "";
                        while (!(operator = operatorStack.pop()).equals("(")) {
                            operandStack.push(operator + "");
                        }
                        break;
                    default:
                        number += expression.charAt(i) + "";
                        if (i + 1 == expression.length() || expression.charAt(i + 1) == '+' || expression.charAt(i + 1) == '¡' || expression.charAt(i + 1) == '!' || expression.charAt(i + 1) == '|' || expression.charAt(i + 1) == '-' || expression.charAt(i + 1) == '*' || expression.charAt(i + 1) == '/' || expression.charAt(i + 1) == '^' || expression.charAt(i + 1) == ')') {
                            number = check(number);
                            operandStack.push(number);
                            number = "";
                        }
                }

                i++;
                if (i == expression.length()) {
                    String operator = "";
                    while (!(operator = operatorStack.pop()).equals("(")) {
                        operandStack.push(operator + "");
                    }
                }
            }
            return operandStack;
        } catch (Exception e) {
            throw new Exception("wrong input");
        }
    }

    public static String check(String toCheck) {
        boolean rint = false;
        if (toCheck.contains("DELTA")){
            rint = true;
        System.out.println("input:" + toCheck);}
        if (toCheck.startsWith("\"") && toCheck.endsWith("\"")){
           
        }
        toCheck = Z80Assembler.setLabels(toCheck);
        toCheck = Z80Assembler.putEQU(toCheck);
        toCheck = Format(toCheck);
        if (toCheck.contains("IX")) {
            toCheck = toCheck.replace("IX", "0");
        }
        if (toCheck.contains("IY")) {
            toCheck = toCheck.replace("IY", "0");
        }
        toCheck = toCheck.replace("#", "&");
        toCheck = toCheck.replace("$", "&");
        if (toCheck.startsWith("-")) {
            System.out.println("Mathparser: minus found!");
//            System.exit(0);
        }
        if (toCheck.startsWith("%")) {
//            System.err.println("BINARY value:" + toCheck);
            toCheck = toCheck.substring(1);
            int val = Integer.parseInt(toCheck, 2);
            toCheck = "" + val;
        }
        if (toCheck.startsWith("&")) {
            try {
                toCheck = "" + hexValue(toCheck.replace("&", ""));
            } catch (Exception e) {
            }
        }
        if (rint)
        System.out.println("output:" + toCheck);
        return toCheck;
    }

    public static int hexValue(String source) throws Exception {
        int result = 0;
        source = source.trim();
        for (int i = 0; i < source.length(); i++) {
            byte val = hexValue(source.charAt(i));
            if (val < 0 || val > 15) {
                throw new Exception("Illegal hex character in " + source);
            }
            result = (result << 4) + val;
        }
        return result;
    }

    public static byte hexValue(char value) {
        if (value >= 'a') {
            return (byte) (value - 'a' + 10);
        } else if (value > '9') {
            return (byte) (value - 'A' + 10);
        } else {
            return (byte) (value - '0');
        }
    }

    public static double calculatePostFix(Stack<String> operandStack) throws Exception {
        Stack<String> stack = new Stack<String>();
        double result = 0.0;
        stack.addAll(operandStack);
        operandStack.clear();
        while (!stack.isEmpty()) {
            operandStack.add(stack.pop());
        }
        try {
            if (operandStack.size() < 3) {
                return Double.parseDouble(operandStack.peek());
            }
            while (!operandStack.isEmpty()) {
                if (!operandStack.peek().matches("[+-/*^|¡!]")) {
                    stack.push(operandStack.pop());
                } else {
                    char operator = operandStack.pop().charAt(0);
                    String buffer = stack.pop();
                    switch (operator) {
                        case '|':
                            result = (int) Double.parseDouble(stack.pop()) & (int) Double.parseDouble(buffer);
                            stack.push(result + "");
                            break;
                        case '!':
                            result = (int) Double.parseDouble(stack.pop()) ^ (int) Double.parseDouble(buffer);
                            stack.push(result + "");
                            break;
                        case '¡':
                            result = (int) Double.parseDouble(stack.pop()) | (int) Double.parseDouble(buffer);
                            stack.push(result + "");
                            break;
                        case '+':
                            result = Double.parseDouble(stack.pop()) + Double.parseDouble(buffer);
                            stack.push(result + "");
                            break;
                        case '-':
                            result = Double.parseDouble(stack.pop()) - Double.parseDouble(buffer);
                            stack.push(result + "");
                            break;
                        case '*':
                            result = Double.parseDouble(stack.pop()) * Double.parseDouble(buffer);
                            stack.push(result + "");
                            break;
                        case '/':
                            result = Double.parseDouble(stack.pop()) / Double.parseDouble(buffer);
                            stack.push(result + "");
                            break;
                        case '^':
                            double a = Double.parseDouble(stack.pop());
                            result = Math.pow(a, Double.parseDouble(buffer));
                            stack.push(result + "");
                            break;
                    }
                }
            }
            return result;
        } catch (Exception e) {
            throw new Exception("Wrong input");
        }
    }

    private static double getResult() {
        return result;
    }

    public static void main(String[] argv) {
//        argv = new String[]{"2^sin(5^(3+5))"};
        if (argv.length < 1 || argv[0].length() == 0) {
            String usage = "Usage: java Parser equation\nYou can set deg: rad: grad:\nExample: 'rad:2^sin(5^(3+5))'";
            System.err.println(usage);
        } else {
            try {
                String g = argv[0];
//                System.out.println("Input: " + g);
                g = parseMaths(g);
//                System.out.println("Result = " + g);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}


Just translate to ASM, remove some JavaCPC specific Z80Assembler Symbol code, and code a little GUI around it... Thats all

[TFM]

Ok, let me just implement this strange language to the CPC...

[Gryzor]

Will it come on ROM?

[TFM]

Will it come on ROM?

Yes, on a 1024 KB one ;-)

[Executioner]

Well, WinAPE does have CTRL-SHIFT-F1/F2 to view disc image contents, but it would be nice to see the directory and be able to double-click a file to mount the image and auto-run a file.

[Cpcmaniaco]

There is a good program that makes many things that I think it will be a good help if it will stay on the emulators.

This is the page of the program, called Disk Image Manager :

http://damieng.com/creative/development/sinclair-spectrum/spin-disk-manager

When I make a dump with SamDisK, I dont know it I make a good dump or not.

With this utility I can see it on the map of the disc with all the tracks and sectors, and I can do many others things.

[Gryzor]

Wow, I had never before heard of this. Iz nice, as Borat would say (especially the track layout, reminds me of Dicsology and ProCopy. But it's a bit too much, and except for the wow factor, not too useful for an Open dialog.

[Devilmarkus]

Working on a new DSKFileDialog:

[Gryzor]

Ooh yeah, that's the stuff!

Now,  how about my initial request?

[Devilmarkus]

Well, reading informations from a DSK is not so simple as reading from a .D64 file.
(At least not in JavaCPC )

But the dialog I made seems to be already very useful...
Check it out here: (Added some UI)
http://cpc-live.com/dskfiledialog

More ideas?

[CanonMan]

First of all, thanks for releasing a new verion after three years. I was beginning to think it would never happen 

I've been using the built-in assembler quite a bit this last couple of weeks, and have a few suggestions for improvements to it. Nothing major, just little changes to make the editor behave the same as a lot of other editor programs do...

First it would be useful to have Ctrl-Insert to copy a block, and also Shift-Delete to cut a block and Shift-Insert to paste a block. I'm used to this arrangement on Programmer's File Editor and MPLAB, so it would be nice to have it here.

Second, when pressing the tab key, the column number in the row:column part of the status bar only increments by one, rather than by the size of the tab stop, which is 8 I think? I always tend to start my comments on column 33. It's a bit tricky to do so with the current arrangement!

There's my suggestions. I can't think of anything else I'd change about WinAPE, it really is that good. Being able to write assembler, test and debug it this easily is ideal. I wished it was that simple 25 years ago... 

[Devilmarkus]

Here's how my final DSK-FileDialog looks like now:


I hopefully can add more DSK formats, soon...
Actually added:
DATA,
SYSTEM,
ROMDOS D10,
ParaDos 80

(The German button-labels are because it's based on the standard FileDialog from Java, so everyone sees these buttons localized to his PC language...)

[Devilmarkus]

Who wants to try it:
http://cpc-live.com/data/download.php?type=-beta&fichier=2011_08_12_JavaCPC_Desktop_BETA.zip

[RockRiver]

I would use BonnyDOS hard disk format image file (or with real second HDD attached to PC from CPC) on Emus with Symbiface support. Which one could I use ? WinAPE ?, JavaCPC ?, CPCE ? Never will be done with modern windows and access to HDD?

If finally will HDOS-IDE/8255 works OK, and becomes a new standard could be supported too on emu?


Still in search of the Lost Ark: FAT16 with real CPC... Although special WinAPE's ROM "cpcdos.rom" (emu only) can read files from the PC hdd. Thanks!! Executioner.

[Devilmarkus]

JavaCPC does not support harddrives / - images...

[RockRiver]

JavaCPC does not support harddrives / - images...

OK. That's why I failed to find that.    What a pity!!!!! 
Thanks for the new Desktop version. [I'm musician, I'm fan of your YM software...]
Please think about HDD on CPC (maybe is an absurd -since HxC - ... but I like it)

[TFM]

JavaCPC does not support harddrives / - images...

It's such a pity that not a single CPC emulator supports the Dobbertin HD20 hard-disc (the most sold ever!). And it would be really easy to do so.