/*
 * @(#) $(JCGO)/jtrsrc/com/ivmaisoft/jcgo/Main.java --
 * a part of JCGO translator.
 **
 * Project: JCGO (http://www.ivmaisoft.com/jcgo/)
 * Copyright (C) 2001-2012 Ivan Maidanski <ivmai@mail.ru>
 * All rights reserved.
 */

/*
 * This is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 **
 * This software is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License (GPL) for more details.
 **
 * Linking this library statically or dynamically with other modules is
 * making a combined work based on this library. Thus, the terms and
 * conditions of the GNU General Public License cover the whole
 * combination.
 **
 * As a special exception, the copyright holders of this library give you
 * permission to link this library with independent modules to produce an
 * executable, regardless of the license terms of these independent
 * modules, and to copy and distribute the resulting executable under
 * terms of your choice, provided that you also meet, for each linked
 * independent module, the terms and conditions of the license of that
 * module. An independent module is a module which is not derived from
 * or based on this library. If you modify this library, you may extend
 * this exception to your version of the library, but you are not
 * obligated to do so. If you do not wish to do so, delete this
 * exception statement from your version.
 */

package com.ivmaisoft.jcgo;

import java.io.*;
import java.util.Enumeration;

/**
 * This is the main class.
 */

public final class Main {

    static final String VERSION = Integer.toString(VerInfo.VER_NUM / 100) + "."
            + Integer.toString((VerInfo.VER_NUM / 10) % 10)
            + Integer.toString(VerInfo.VER_NUM % 10);

    static final String VER_ABBR = "JCGO_"
            + VERSION.substring(0, VERSION.length() - 3)
            + VERSION.substring(VERSION.length() - 2);

    static CompilationUnit curUnit;

    static final ClassDictionary dict = new ClassDictionary();

    private Main() {
    }

    static void showProgInfo() {
        System.out.println("JCGO v" + VERSION
                + " - Java source to C code translator");
        System.out.println(VerInfo.COPYRIGHT_AUTHOR);
        System.out.println(VerInfo.COPYRIGHT);
        System.out.println("This is free software. All rights reserved."
                + " See LICENSE and README files.");
        System.out.println("");
    }

    private static void showUsage() {
        System.out
                .println("Usage: jcgo [options] <target_class> [<additional_class1> ...]");
        System.out.println("Options:");
        System.out.println(" -sourcepath <pathlist> "
                + " Specify where to find input source files");
        System.out.println(" -d <directory> "
                + " Specify where to place generated files");
        System.out.println(" -verbose " + " Verbose mode");
        System.out.println(" -r[[p]c][g|[p]m][[p]f] <packageOrClass> "
                + " Force class members reflection");
        System.out.println("@<filename> "
                + " Specify additional classes in the file");
        System.out.println("");
    }

    public static void main(String[] argv) {
        int consumed = getAmountOfUsedMemory();
        try {
            boolean showHelp = false;
            if (argv.length == 0 || (argv.length == 1 && argv[0].equals("-h"))) {
                showProgInfo();
                showUsage();
                showHelp = true;
            }
            if (showHelp) {
                System.exit(0);
            }
            boolean skipClinitTrace = false;
            String progBasePath = getProgBasePath();
            String mainClassName = null;
            ObjQueue classnames = new ObjQueue();
            for (int i = 0; i < argv.length; i++) {
                if (argv[i].startsWith("-")) {
                    if (argv[i].equals("-t")) {
                        skipClinitTrace = true;
                    } else if (!processSimpleOption(argv[i])) {
                        if (i + 1 >= argv.length) {
                            System.err
                                    .println("missing argument for last option");
                            System.exit(2);
                        }
                        if (argv[i].equals("-sourcepath")
                                || argv[i].equals("-src")) {
                            dict.javaFiles.setClassPath(argv[i + 1],
                                    progBasePath);
                        } else if (!processOptionWithArg(argv[i], argv[i + 1])) {
                            System.err.println("invalid option: " + argv[i]);
                            System.exit(2);
                        }
                        i++;
                    }
                } else {
                    String className = argv[i];
                    if (className.charAt(0) == '@') {
                        readResponseFile(
                                classnames,
                                className.length() == 1 && i + 1 < argv.length ? argv[++i]
                                        : className.substring(1), progBasePath);
                    } else if (mainClassName != null) {
                        classnames.addLast(dict.javaFiles
                                .toClassName(className));
                    } else {
                        mainClassName = dict.javaFiles.toClassName(className);
                    }
                }
            }
            if (mainClassName == null) {
                System.err.println("Target class must be specified");
                System.exit(2);
            }
            dict.javaFiles.setClassPath();
            String[] sortednames = strsQueueToSortedArr(classnames);
            if (dict.outPath.length() == 0) {
                if (isOutPathRequired(progBasePath)) {
                    System.err
                            .println("Use -d to specify existing directory for output");
                    System.exit(2);
                }
                (new File(dict.outPath = "jcgo_Out")).mkdir();
            }
            int time = (int) System.currentTimeMillis();
            ClassDefinition mainClass = processFirst(mainClassName);
            for (int i = 0; i < sortednames.length; i++) {
                ObjQueue proxyIfaceNames = dict.nameMapper
                        .decodeProxyClassName(sortednames[i]);
                if (proxyIfaceNames != null) {
                    Enumeration en = proxyIfaceNames.elements();
                    while (en.hasMoreElements()) {
                        dict.get((String) en.nextElement())
                                .predefineClass(null);
                    }
                } else {
                    dict.get(sortednames[i]).predefineClass(null);
                }
            }
            processAll(mainClass, sortednames, time, skipClinitTrace);
        } catch (TranslateException e) {
            System.err.println(e.getMessage());
            System.exit(6);
        } catch (RuntimeException e) {
            if (dict.verbose) {
                e.printStackTrace(System.out);
            }
            System.err.println(e.toString());
            System.exit(7);
        } catch (OutOfMemoryError e) {
            System.err.print(" Out of memory ");
            try {
                System.err.print("(consumed "
                        + Integer.toString(getAmountOfUsedMemory() - consumed)
                        + " KiB)");
            } catch (OutOfMemoryError ee) {
            }
            System.err.println("");
            System.exit(255);
        }
        System.exit(0);
    }

    private static boolean processSimpleOption(String option) {
        if (option.equals("-verbose") || option.equals("-v")) {
            dict.verbose = true;
            return true;
        } else if (option.equals("-v2")) {
            dict.verbose = dict.verboseTracing = true;
            return true;
        } else if (option.equals("-e")) {
            dict.ignoreErrs = true;
            return true;
        } else if (option.startsWith("-l") && dict.failOnClassLimit == 0) {
            dict.failOnClassLimit = (new ConstValue(option.substring(2)))
                    .getIntValue();
            return true;
        } else {
            return false;
        }
    }

    private static boolean processOptionWithArg(String option, String value) {
        if (option.equals("-d") && dict.outPath.length() == 0) {
            if (!new File(value).isDirectory()) {
                System.err.println("Output directory does not exist: " + value);
                System.exit(2);
            }
            dict.outPath = value;
            return true;
        } else if (option.startsWith("-r")) {
            processReflectOption(option.substring(2), value);
            return true;
        } else if (option.equals("-c") && dict.failOnClassName == null) {
            dict.failOnClassName = value;
            return true;
        } else if (option.equals("-f") && dict.failOnFieldName == null) {
            dict.failOnFieldName = value;
            return true;
        } else if (option.equals("-m") && dict.failOnMethodId == null) {
            dict.failOnMethodId = value;
            return true;
        } else {
            return false;
        }
    }

    private static void processReflectOption(String flags, String packageOrClass) {
        if (packageOrClass.equals("*") || packageOrClass.equals(".*")) {
            packageOrClass = "";
        }
        if (dict.forcedReflectClassOrPkg.put(packageOrClass, flags) != null
                || packageOrClass.indexOf('/', 0) > 0
                || (File.separatorChar != '/' && packageOrClass.indexOf(
                        File.separatorChar, 0) > 0)) {
            System.err.println("Invalid or duplicate -r<flags> for: "
                    + (packageOrClass.length() > 0 ? packageOrClass
                            : "(unnamed package)"));
            System.exit(2);
        }
    }

    private static String[] strsQueueToSortedArr(ObjQueue queue) {
        String[] strs = new String[queue.countSize()];
        queue.copyInto(strs);
        String[] sortedstrs = new String[strs.length];
        System.arraycopy(strs, 0, sortedstrs, 0, strs.length);
        ClassDefinition.mergeSort(strs, sortedstrs, 0, strs.length);
        return sortedstrs;
    }

    private static boolean isOutPathRequired(String progBasePath) {
        String userDir = ".";
        try {
            userDir = System.getProperty("user.dir", userDir);
        } catch (SecurityException e) {
        }
        return userDir.equals(progBasePath) || progBasePath.equals(".")
                || userDir.startsWith(progBasePath + File.separator);
    }

    private static String getProgBasePath() {
        String pathList = "";
        try {
            pathList = System.getProperty("java.class.path", pathList);
        } catch (SecurityException e) {
        }
        int pos = 0;
        String firstBasePath = ".";
        do {
            int next = pathList.indexOf(File.pathSeparatorChar, pos);
            if (next < 0) {
                next = pathList.length();
            }
            String basePath = getParentPathIfJar(pathList.substring(pos, next));
            if ((new File(basePath, "goclsp")).isDirectory())
                return basePath;
            if (firstBasePath.equals(".")) {
                firstBasePath = basePath;
            }
            pos = next + 1;
        } while (pathList.length() >= pos);
        return firstBasePath;
    }

    static String getParentPathIfJar(String path) {
        if ((path.endsWith(".jar") || path.endsWith(".Jar")
                || path.endsWith(".JAR") || path.endsWith(".zip")
                || path.endsWith(".Zip") || path.endsWith(".ZIP"))
                && (path = (new File(path)).getParent()) == null) {
            path = "";
        }
        return path.length() > 0 ? path : ".";
    }

    private static int getAmountOfUsedMemory() {
        return (int) ((Runtime.getRuntime().totalMemory() - Runtime
                .getRuntime().freeMemory()) >> 10);
    }

    static void parseJavaFile(String classname) {
        String fileName = dict.javaFiles.classFilename(classname, true);
        if (fileName == null) {
            System.err.println("Cannot find class: " + classname);
            System.exit(5);
        }
        dict.filesParsed++;
        dict.message("Parsing file: " + fileName);
        Scanner.Init(fileName);
        dict.inBytesCount += (int) (new File(fileName)).length();
        Parser.Parse();
        Term t = curUnit;
        if (Scanner.err.count > 0)
            throw new TranslateException("Lexical error in file: " + fileName);
        Context c = new Context();
        c.fileName = fileName;
        t.processPass0(c);
        t.processPass1(c);
    }

    static ObjQueue readFileOfLines(String fname) {
        ObjQueue lines = new ObjQueue();
        try {
            BufferedReader infile = new BufferedReader(new FileReader(fname));
            // Portability - use the following for Java 1.0
            // DataInputStream infile = new DataInputStream(new
            // BufferedInputStream(new FileInputStream(fname)));
            String str;
            while ((str = infile.readLine()) != null) {
                lines.addLast(str);
            }
            infile.close();
        } catch (IOException e) {
            lines = null;
        }
        return lines;
    }

    private static void readResponseFile(ObjQueue classnames, String fname,
            String progBasePath) {
        ObjQueue lines = readFileOfLines(JavaSrcFiles.adjustPathPrefix(fname,
                progBasePath));
        if (lines == null) {
            System.err.println("Cannot read response file: " + fname);
            System.exit(2);
        }
        Enumeration en = lines.elements();
        while (en.hasMoreElements()) {
            String str = ((String) en.nextElement()).trim();
            char ch;
            if (str.length() > 0 && (ch = str.charAt(0)) != '!' && ch != '#'
                    && ch != ';') {
                String path = cutLinePrefix(str, "-sourcepath");
                int pos;
                if (path != null || (path = cutLinePrefix(str, "-src")) != null) {
                    dict.javaFiles.setClassPath(path, progBasePath);
                } else if (str.startsWith("-r")
                        && ((pos = str.indexOf(' ', 2)) >= 0 || (pos = str
                                .indexOf('\t', 2)) >= 0)) {
                    processReflectOption(str.substring(2, pos),
                            str.substring(pos + 1).trim());
                } else {
                    classnames.addLast(dict.javaFiles.toClassName(str));
                }
            }
        }
    }

    private static String cutLinePrefix(String str, String prefix) {
        return str.startsWith(prefix) && str.length() > prefix.length()
                && str.charAt(prefix.length()) <= ' ' ? str.substring(
                prefix.length() + 1).trim() : null;
    }

    private static ClassDefinition processFirst(String classname) {
        System.out.println("Initializing...");
        dict.setupCoreClasses();
        ClassDefinition mainClass = dict.get(classname);
        MethodDefinition md = mainClass.getMethod(Names.SIGN_MAIN);
        if (md == null || !md.isClassMethod()) {
            dict.fatal(mainClass.passOneContext().fileName, 1,
                    "Cannot find static method: main(String[])");
        }
        dict.get(Names.JAVA_LANG_CLASS).define(mainClass);
        dict.get(Names.JAVA_LANG_STRING).define(mainClass);
        return mainClass;
    }

    private static ObjVector namesToClassLiterals(ObjQueue classNames) {
        ObjVector parmSig = new ObjVector();
        Enumeration en = classNames.elements();
        while (en.hasMoreElements()) {
            parmSig.addElement(dict.get((String) en.nextElement()));
        }
        return parmSig;
    }

    private static void processAll(ClassDefinition mainClass,
            String[] sortednames, int time, boolean skipClinitTrace) {
        System.out.println("Analysis pass...");
        mainClass.markMethod(Names.SIGN_MAIN);
        for (int i = 0; i < sortednames.length; i++) {
            ObjQueue proxyIfaceNames = dict.nameMapper
                    .decodeProxyClassName(sortednames[i]);
            if (proxyIfaceNames == null
                    || dict.addProxyClass(
                            namesToClassLiterals(proxyIfaceNames), null) == null) {
                ClassDefinition cd = dict.get(sortednames[i]);
                cd.markUsed();
                cd.markAllNatives();
                dict.dynClassesToTrace.put(cd, cd);
            }
        }
        mainClass.markAllPublicStaticMethods();
        dict.producePassOne();
        boolean mainReflected = false;
        if (dict.forcedReflectClassOrPkg.size() > 0) {
            ObjQueue forcedClassNames = new ObjQueue();
            Enumeration en = dict.forcedReflectClassOrPkg.keys();
            while (en.hasMoreElements()) {
                String packageOrClass = (String) en.nextElement();
                if (packageOrClass.length() > 0
                        && !packageOrClass.endsWith(".*")) {
                    forcedClassNames.addLast(packageOrClass);
                }
            }
            sortednames = strsQueueToSortedArr(forcedClassNames);
            if (sortednames.length > 0) {
                for (int i = 0; i < sortednames.length; i++) {
                    dict.get(sortednames[i]).define(mainClass);
                }
                if (dict.hasReflectedMethods) {
                    mainClass.reflectAllPublicStaticMethods();
                    mainReflected = true;
                }
                dict.producePassOne();
            }
        }
        if (dict.hasReflectedMethods && !mainReflected
                && mainClass.reflectAllPublicStaticMethods()) {
            dict.producePassOne();
        }
        dict.allowConstStr = Main.dict.get(Names.JAVA_LANG_STRING)
                .otherInstanceFieldsUnused(Names.fieldsOrderString);
        System.out.println("Output pass...");
        dict.mainClass = mainClass;
        Enumeration en = dict.usedClasses();
        while (en.hasMoreElements()) {
            ((ClassDefinition) en.nextElement()).prepareMethodsForOutput();
        }
        dict.get(Names.JAVA_LANG_OBJECT).produceOutputRecursive(
                new ObjHashSet());
        System.out.println("Writing class tables...");
        ClassDefinition.setSpecialVirtual();
        Enumeration en2 = dict.usedClasses();
        while (en2.hasMoreElements()) {
            ((ClassDefinition) en2.nextElement()).finishClass();
        }
        System.out.println("Creating main file...");
        mainClass.buildMain(skipClinitTrace);
        System.out.println("Parsed: " + Integer.toString(dict.filesParsed)
                + " java files (" + Integer.toString(dict.inBytesCount >> 10)
                + " KiB). Analyzed: " + Integer.toString(dict.methodsAnalyzed)
                + " methods.");
        System.out.println("Produced: " + Integer.toString(dict.outFilesCount)
                + " c/h files (" + Integer.toString(dict.outBytesCount >> 10)
                + " KiB).");
        System.out.println("Contains: " + Integer.toString(dict.methodsWritten)
                + " java methods, " + Integer.toString(dict.normalCalls)
                + " normal and " + Integer.toString(dict.indirectCalls)
                + " indirect calls.");
        System.out
                .println("Done conversion in "
                        + Integer.toString(((int) System.currentTimeMillis() - time) / 1000)
                        + " seconds. Total heap size: "
                        + Integer.toString((int) (Runtime.getRuntime()
                                .totalMemory() >> 10)) + " KiB.");
        if (dict.errorsCnt > 0) {
            System.out.println("");
            System.out.println(" Translated with " + dict.errorsCnt
                    + " errors!");
            System.exit(3);
        }
    }
}