smc.java

SMC takes a state machine stored in a .sm file and generates a State pattern in twelve programming l

            if (e1 != null)
            {
                retval.add(e1);
            }

            for (; it1.hasNext() == true;)
            {
                retval.add(it1.next());
            }
        }
        else if (it2.hasNext() == true || e2 != null)
        {
            if (e2 != null)
            {
                retval.add(e2);
            }

            for (; it2.hasNext() == true;)
            {
                retval.add(it2.next());
            }
        }

        return (retval);
    }

    // Place a backslash escape character in front of backslashes
    // and doublequotes.
    public static String escape(String s)
    {
        String retval;

        if (s.indexOf('\\') < 0 && s.indexOf('"') < 0)
        {
            retval = s;
        }
        else
        {
            StringBuffer buffer =
                new StringBuffer(s.length() * 2);
            int index;
            int length = s.length();
            char c;

            for (index = 0; index < length; ++index)
            {
                c = s.charAt(index);
                if (c == '\\' || c == '"')
                {
                    buffer.append('\\');
                }

                buffer.append(c);
            }

            retval = buffer.toString();
        }

        return (retval);
    }

    // Outputs a list of warning and error messages.
    public static void outputMessages(String srcFileName,
                                      PrintStream stream,
                                      List<SmcMessage> messages)
    {
        for (SmcMessage message: messages)
        {
            stream.print(srcFileName);
            stream.print(':');
            stream.print(message.getLineNumber());

            if (message.getLevel() == SmcMessage.WARNING)
            {
                stream.print(": warning - ");
            }
            else
            {
                stream.print(": error - ");
            }

            stream.println(message.getText());
        }

        return;
    }

    private static boolean parseArgs(String[] args)
    {
        int i;
        int argsConsumed;
        boolean helpFlag = false;
        boolean retcode = true;

        // Look for either -help or -verson first. If specified,
        // then output the necessary info and return.
        helpFlag = _needHelp(args);
        if (helpFlag == false)
        {
            // Look for the target language second. Verify that
            // exactly one target language is specifed.
            try
            {
                _targetLanguage = _findTargetLanguage(args);
            }
            catch (IllegalArgumentException argex)
            {
                retcode = false;
                _errorMsg = argex.getMessage();
            }

            if (retcode == true && _targetLanguage == null)
            {
                retcode = false;
                _errorMsg = "Target language was not specified.";
            }
        }

        // Parse all options first. Keep going until an error is
        // encountered or there are no more options left.
        for (i = 0, argsConsumed = 0;
             i < args.length &&
                 helpFlag == false &&
                 retcode == true &&
                 args[i].startsWith("-") == true;
             i += argsConsumed, argsConsumed = 0)
        {
            // Ignore the target language flags - they have
            // been processed.
            if (_findLanguage(args[i]) != null)
            {
                argsConsumed = 1;
            }
            else if (args[i].startsWith("-sy") == true)
            {
                if (_supportsOption(SYNC_FLAG) == false)
                {
                    retcode = false;
                    _errorMsg =
                        _targetLanguage.name() +
                        " does not support " +
                        SYNC_FLAG +
                        ".";
                }
                else
                {
                    _sync = true;
                    argsConsumed = 1;
                }
            }
            else if (args[i].startsWith("-su") == true)
            {
                // -suffix should be followed by a suffix.
                if ((i + 1) == args.length ||
                    args[i+1].startsWith("-") == true)
                {
                    retcode = false;
                    _errorMsg =
                        SUFFIX_FLAG + " not followed by a value";
                }
                else if (_supportsOption(SUFFIX_FLAG) == false)
                {
                    retcode = false;
                    _errorMsg =
                        _targetLanguage.name() +
                        " does not support " +
                        SUFFIX_FLAG +
                        ".";
                }
                else
                {
                    _suffix = args[i+1];
                    argsConsumed = 2;
                }
            }
            else if (args[i].startsWith("-ca") == true)
            {
                // -cast should be followed by a cast type.
                if ((i + 1) == args.length ||
                    args[i+1].startsWith("-") == true)
                {
                    retcode = false;
                    _errorMsg =
                        CAST_FLAG +
                        " not followed by a value";
                }
                else if (_supportsOption(CAST_FLAG) == false)
                {
                    retcode = false;
                    _errorMsg =
                        _targetLanguage.name() +
                        " does not support " +
                        CAST_FLAG +
                        ".";
                }
                else if (_isValidCast(args[i+1]) == false)
                {
                    retcode = false;
                    _errorMsg =
                        "\"" +
                        args[i+1] +
                        "\" is an invalid C++ cast type.";
                }
                else
                {
                    _castType = args[i+1];
                    argsConsumed = 2;
                }
            }
            else if (args[i].equals("-d") == true)
            {
                // -d should be followed by a directory.
                if ((i + 1) == args.length ||
                    args[i+1].startsWith("-") == true)
                {
                    retcode = false;
                    _errorMsg =
                        DIRECTORY_FLAG +
                        " not followed by directory";
                }
                else if (
                    _supportsOption(DIRECTORY_FLAG) == false)
                {
                    retcode = false;
                    _errorMsg =
                        _targetLanguage.name() +
                        " does not support " +
                        DIRECTORY_FLAG +
                        ".";
                }
                else
                {
                    _outputDirectory = args[i+1];
                    argsConsumed = 2;

                    // If the output directory does not end with
                    // file path separator, then add one.
                    if (_outputDirectory.endsWith(
                            File.separator) == false)
                    {
                        _outputDirectory =
                            _outputDirectory + File.separator;
                    }

                    retcode =
                        _isValidDirectory(_outputDirectory);
                }
            }
            else if (args[i].startsWith("-hea") == true)
            {
                // -headerd should be followed by a directory.
                if ((i + 1) == args.length ||
                    args[i+1].startsWith("-") == true)
                {
                    retcode = false;
                    _errorMsg = HEADER_FLAG +
                                " not followed by directory";
                }
                else if (
                    _supportsOption(HEADER_FLAG) == false)
                {
                    retcode = false;
                    _errorMsg =
                        _targetLanguage.name() +
                        " does not support " +
                        HEADER_FLAG +
                        ".";
                }
                else
                {
                    _headerDirectory = args[i+1];
                    argsConsumed = 2;

                    // If the output directory does not end with
                    // file path separator, then add one.
                    if (_headerDirectory.endsWith(
                            File.separator) == false)
                    {
                        _headerDirectory =
                            _headerDirectory + File.separator;
                    }

                    retcode =
                        _isValidDirectory(_headerDirectory);
                }
            }
            else if (args[i].startsWith("-gl") == true)
            {
                // -glevel should be followed by an integer.
                if ((i + 1) == args.length ||
                    args[i+1].startsWith("-") == true)
                {
                    retcode = false;
                    _errorMsg =
                        GLEVEL_FLAG +
                        " not followed by integer";
                }
                else if (_supportsOption(GLEVEL_FLAG) == false)
                {
                    retcode = false;
                    _errorMsg =
                        _targetLanguage.name() +
                        " does not support " +
                        GLEVEL_FLAG +
                        ".";
                }
                else
                {
                    try
                    {
                        _graphLevel =
                            Integer.parseInt(args[i+1]);

                        if (_graphLevel < GRAPH_LEVEL_0 ||
                            _graphLevel > GRAPH_LEVEL_2)
                        {
                            retcode = false;
                            _errorMsg =
                                GLEVEL_FLAG +
                                " must be 0, 1 or 2";
                        }
                        else
                        {
                            argsConsumed = 2;
                        }
                    }
                    catch (NumberFormatException numberex)
                    {
                        retcode = false;

                        _errorMsg =
                            GLEVEL_FLAG +
                            " not followed by valid integer";
                    }
                }
            }
            else if (args[i].equals("-g") == true)
            {
                if (_supportsOption(DEBUG_FLAG) == false)
                {
                    retcode = false;
                    _errorMsg =
                        _targetLanguage.name() +
                        " does not support " +
                        DEBUG_FLAG +
                        ".";
                }
                else
                {
                    _debug = true;
                    argsConsumed = 1;
                }
            }
            else if (args[i].startsWith("-nos") == true)
            {
                if (_supportsOption(NO_STREAMS_FLAG) == false)
                {
                    retcode = false;
                    _errorMsg =
                        _targetLanguage.name() +
                        " does not support " +
                        NO_STREAMS_FLAG +
                        ".";
                }
                else
                {
                    _nostreams = true;
                    argsConsumed = 1;
                }
            }
            else if (args[i].startsWith("-noe") == true)
            {
                if (_supportsOption(NO_EXCEPTIONS_FLAG) == false)
                {
                    retcode = false;
                    _errorMsg =
                        _targetLanguage.name() +
                        " does not support " +
                        NO_EXCEPTIONS_FLAG +
                        ".";
                }
                else
                {
                    _noex = true;
                    argsConsumed = 1;
                }
            }
            else if (args[i].startsWith("-noc") == true)
            {
                if (_supportsOption(NO_CATCH_FLAG) == false)
                {
                    retcode = false;
                    _errorMsg =
                        _targetLanguage.name() +
                        " does not support " +
                        NO_CATCH_FLAG +
                        ".";