#
# Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License version 2 only, as
# published by the Free Software Foundation.  Oracle designates this
# particular file as subject to the "Classpath" exception as provided
# by Oracle in the LICENSE file that accompanied this code.
#
# This code 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
# version 2 for more details (a copy is included in the LICENSE file that
# accompanied this code).
#
# You should have received a copy of the GNU General Public License version
# 2 along with this work; if not, write to the Free Software Foundation,
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
# or visit www.oracle.com if you need additional information or have any
# questions.
#

string.script.error=\
	script error: {0}

file.script.error=\
	script error in file {0} : {1}

file.not.found=\
	script file {0} is not found

engine.not.found=\
	script engine for language {0} can not be found

engine.info=\
	Language {0} {1} implemention "{2}" {3}

encoding.unsupported=\
	encoding {0} is not supported

main.usage=\
Usage: {0} [options] [arguments...]\n\
\n\
where [options] include:\n\
\  \-classpath <path>    Specify where to find user class files \n\
\  \-cp <path>           Specify where to find user class files \n\
\  \-D<name>=<value>     Set a system property \n\
\  \-J<flag>             Pass <flag> directly to the runtime system \n\
\  \-l <language>        Use specified scripting language \n\
\  \-e <script>          Evaluate given script \n\
\  \-encoding <encoding> Specify character encoding used by script files \n\
\  \-f <script file>     Evaluate given script file \n\
\  \-f -                 Interactive mode, read script from standard input \n\
\  \                     If this is used, this should be the last -f option \n\
\  \-help                Print this usage message and exit \n\
\  \-?                   Print this usage message and exit \n\
\  \-q                   List all scripting engines available and exit \n\
\  \n\
If [arguments..] are present and if no -e or -f option is used, then first\n\
argument is script file and the rest of the arguments, if any, are passed\n\
as script arguments. If [arguments..] and -e or -f option is used, then all\n\
[arguments..] are passed as script arguments. If [arguments..], -e, -f are\n\
missing, then interactive mode is used.
