Example #1
0
        public static int Main(string[] args)
        {
            LogFile.AddLine("================= Start of process =================");
            LogFile.AddLine("Command line: <" + Environment.CommandLine + ">");
            bool testedLock = false;

            ErrorCodes ret = ErrorCodes.None;

            try
            {
                CommandLineParser             argParser   = new CommandLineParser();
                CommandLineParser.ParseResult parseResult = argParser.Parse(args);
                switch (parseResult)
                {
                case CommandLineParser.ParseResult.error:
                    ret = ErrorCodes.CommandLine;
                    int iRet = (int)ErrorCodes.CommandLine;
                    LogFile.Release();
                    return(iRet);

                case CommandLineParser.ParseResult.stop:
                    LogFile.Release();
                    // no error - success
                    return((int)(ErrorCodes.Success));
                }

                // tests the command line parser to make sure we have valid data
                if (argParser.FlagUsed(CommandLineParser.Flag.dontDoAnything))
                {
                    foreach (CommandLineParser.Flag flag in argParser.FlagsUsed())
                    {
                        Console.Write("{0}:{1}, ", flag.ToString(), argParser.FlagData(flag));
                    }
                    Console.WriteLine();
                    return((int)ErrorCodes.Success);
                }

                // don't restrict the GUI
                bool runSilent = false;
                if (argParser.FlagUsed(CommandLineParser.Flag.q))
                {
                    runSilent = true;
                }

                bool slow = false;
                // Use the old slower file reading method
                if (argParser.FlagUsed(CommandLineParser.Flag.slow))
                {
                    slow = true;
                }

                if (argParser.FlagUsed(CommandLineParser.Flag.testMainParserRoutine))
                {
                    LocaleFileClass localeObject   = new LocaleFileClass();
                    bool            successParsing = localeObject.TestBaseLocaleParsers(false);
                    if (successParsing)
                    {
                        ret = ErrorCodes.Success;
                    }
                    else
                    {
                        ret = ErrorCodes.LDParsingError;
                    }
                }


                if (argParser.FlagUsed(CommandLineParser.Flag.testICUDataParser))
                {
                    try
                    {
                        IcuDataNode.TestIcuDataNode(argParser.FlagData(CommandLineParser.Flag.testICUDataParser));
                        ret = ErrorCodes.Success;
                    }
                    catch (LDExceptions e)
                    {
                        ret = e.ec;
                        LogFile.AddErrorLine("LDException: " + e.ec.ToString() + "-" + Error.Text(e.ec));
                        if (e.HasConstructorText)
                        {
                            LogFile.AddErrorLine("LDException Msg: " + e.ConstructorText);
                        }
                    }
                    catch (System.Exception e)
                    {
                        ret = ErrorCodes.NonspecificError;
                        LogFile.AddErrorLine(e.Message);
                        LogFile.AddErrorLine(e.StackTrace);
                    }
                }

                if (argParser.FlagUsed(CommandLineParser.Flag.s))
                {
                    LocaleFileClass localeObject = new LocaleFileClass();
                    localeObject.RunSilent = runSilent;
                    ret = localeObject.ShowCustomLocales();
                }

                if (argParser.FlagUsed(CommandLineParser.Flag.customLanguages))
                {
                    LocaleFileClass localeObject = new LocaleFileClass();
                    localeObject.RunSilent = runSilent;
                    ret = localeObject.ShowCustomLanguages();
                }

                if (argParser.FlagUsed(CommandLineParser.Flag.o))                       // restore origs'
                {
                    CallingID cid = CallingID.CID_RESTORE;
                    if (argParser.FlagUsed(CommandLineParser.Flag.newlang))
                    {
                        cid = CallingID.CID_NEW;                                // internal new lang case
                    }
                    if (!CheckForIcuLocked(null, runSilent, cid))
                    {
                        return((int)ErrorCodes.CancelAccessFailure);
                    }
                    testedLock = true;
                    // only perform this command by itself even if given with other options
                    LocaleFileClass restoreFiles = new LocaleFileClass();
                    restoreFiles.RunSlow   = slow;
                    restoreFiles.RunSilent = runSilent;
                    // Restore all the original files, installing the PUA characters if requested.
                    ret = restoreFiles.RestoreOrigFiles(true);

                    // LT-5374 : wasn't moving the res files from the Icu34 dir to the Icudt34l dir
                    if (ret == ErrorCodes.Success)
                    {
                        // remove the backup files from the undo/recover file name list
                        restoreFiles.RemoveBackupFiles();
                    }
                    restoreFiles.RemoveTempFiles();
                    restoreFiles.MoveNewResFilesToSubDir();
                }

                if (argParser.FlagUsed(CommandLineParser.Flag.r))                       // remove locale
                {
                    if (!testedLock && !CheckForIcuLocked(argParser.FlagData(CommandLineParser.Flag.r), runSilent, CallingID.CID_REMOVE))
                    {
                        return((int)ErrorCodes.CancelAccessFailure);
                    }
                    testedLock = true;
                    string deleteLocale = argParser.FlagData(CommandLineParser.Flag.r);
                    argParser.RemoveFlag(CommandLineParser.Flag.r);
                    bool rUsed = argParser.FlagUsed(CommandLineParser.Flag.r);

                    LocaleFileClass removeLocaleObject = new LocaleFileClass();
                    try
                    {
                        removeLocaleObject.RunSilent = runSilent;
                        ret = removeLocaleObject.RemoveLocale(deleteLocale);
                        removeLocaleObject.MoveNewResFilesToSubDir();
                    }
                    catch (System.Exception e)
                    {
                        ret = ErrorCodes.NonspecificError;

                        LogFile.AddErrorLine(e.Message);
                        LogFile.AddErrorLine(e.StackTrace);
                        LogFile.AddErrorLine("Exception: " + ret.ToString() + "-" + Error.Text(ret));
                        removeLocaleObject.RestoreFiles();                              // copy backup files to original files.
                    }
                }
                // install locale
                if ((ret == ErrorCodes.Success || ret == ErrorCodes.None) &&
                    argParser.FlagUsed(CommandLineParser.Flag.i))
                {
                    CallingID cid = CallingID.CID_INSTALL;
                    if (argParser.FlagUsed(CommandLineParser.Flag.newlang))
                    {
                        cid = CallingID.CID_NEW;                                // internal new lang case
                    }
                    if (!testedLock && !CheckForIcuLocked(
                            argParser.FlagData(CommandLineParser.Flag.i), runSilent, cid))
                    {
                        return((int)ErrorCodes.CancelAccessFailure);
                    }
                    testedLock = true;
                    LocaleFileClass localeFileObject = new LocaleFileClass();
                    localeFileObject.RunSilent = runSilent;
                    localeFileObject.RunSlow   = slow;
                    try
                    {
                        string addLocale = argParser.FlagData(CommandLineParser.Flag.i);
                        localeFileObject.InstallLDFile(addLocale);
                        ret = ErrorCodes.Success;
                    }
                    catch (LDExceptions e)
                    {
                        localeFileObject.RestoreFiles();                                // copy backup files to original files.
                        ret = e.ec;
                        LogFile.AddErrorLine("LDException: " + e.ec.ToString() + "-" + Error.Text(e.ec));
                        if (e.HasConstructorText)
                        {
                            LogFile.AddErrorLine("LDException Msg: " + e.ConstructorText);
                        }
                    }
                    catch (System.Exception e)
                    {
                        ret = ErrorCodes.NonspecificError;

                        LogFile.AddErrorLine(e.Message);
                        LogFile.AddErrorLine(e.StackTrace);
                        LogFile.AddErrorLine("Exception: " + ret.ToString() + "-" + Error.Text(ret));
                        localeFileObject.RestoreFiles();                                // copy backup files to original files.
                    }

                    if (ret == ErrorCodes.Success)
                    {
                        // remove the backup files from the undo/recover file name list
                        localeFileObject.RemoveBackupFiles();
                    }

                    localeFileObject.RemoveTempFiles();
                    localeFileObject.MoveNewResFilesToSubDir();
                }

                //Add PUA Character
                if ((ret == ErrorCodes.Success || ret == ErrorCodes.None) &&
                    argParser.FlagUsed(CommandLineParser.Flag.c))
                {
                    if (!testedLock && !CheckForIcuLocked(argParser.FlagData(CommandLineParser.Flag.c), runSilent, CallingID.CID_UNKNOWN))
                    {
                        return((int)ErrorCodes.CancelAccessFailure);
                    }
                    LocaleFileClass localeFileObject = new LocaleFileClass();
                    localeFileObject.RunSilent = runSilent;
                    try
                    {
                        string addLocale = argParser.FlagData(CommandLineParser.Flag.c);
                        localeFileObject.InstallPUACharacters(addLocale);
                        ret = ErrorCodes.Success;
                    }
                    catch (LDExceptions e)
                    {
                        // copy backup files to original files.
                        localeFileObject.RestoreFiles();
                        ret = e.ec;
                        LogFile.AddErrorLine("LDException: " + e.ec.ToString() + "-" + Error.Text(e.ec));
                        if (e.HasConstructorText)
                        {
                            LogFile.AddErrorLine("LDException Msg: " + e.ConstructorText);
                        }
                    }
                    catch (System.Exception e)
                    {
                        ret = ErrorCodes.NonspecificError;
                        LogFile.AddErrorLine("Exception: " + e.Message);
                        LogFile.AddErrorLine(e.StackTrace);
                        LogFile.AddErrorLine("Error Code: " + ret.ToString() + "-" + Error.Text(ret));
                        localeFileObject.RestoreFiles();                                // copy backup files to original files.
                    }
                    if (ret == ErrorCodes.Success)
                    {
                        // remove the backup files from the undo/recover file name list
                        localeFileObject.RemoveBackupFiles();
                    }

                    localeFileObject.RemoveTempFiles();
                }

                if (ret == ErrorCodes.Success)
                {
                    if (argParser.FlagUsed(CommandLineParser.Flag.q))
                    {
                        LogFile.AddLine("--- Success ---");
                    }
                    else
                    {
                        LogFile.AddErrorLine("--- Success ---");
                    }
                }
            }
            catch (System.Exception e)
            {
                ret = ErrorCodes.NonspecificError;
                LogFile.AddErrorLine("Exception: " + e.Message + " " + e.StackTrace);
                LogFile.AddErrorLine("Exception: " + ret.ToString() + "-" + Error.Text(ret));
            }
            finally
            {
                LogFile.Release();
            }

            int nret = (int)ret;

            return(nret);
        }