Compiler warning Question

4 Message(s) by 3 Author(s) originally posted in java language

From: Jeremy

Date: Wednesday, March 28, 2007

As you can see, My program

<programming> (Or "computer program", "program", "code") The
	instructions executed by a computer, as opposed to the
	physical device on which they run (the "{hardware}").

	The term was coined by the eminent statistician, {John Tukey}.

	Programs stored on {non-volatile storage} built from
	{integrated circuits} (e.g. {ROM} or {PROM}) are usually
	called {firmware}.

	Software can be split into two main types - {system software}
	and application software or {application programs}.  System
	software is any software required to support the production or
	execution of application programs but which is not specific to
	any particular application.  Examples of system software would
	include the {operating system}, {compilers}, editors and
	sorting programs.

	Examples of application programs would include an accounts
	package or a {CAD} program.  Other broad classes of
	application software include {real-time} software, {business
	software}, scientific and engineering software, {embedded
	software}, personal computer software and {artificial
	intelligence} software.

	Software includes both {source code} written by humans and
	executable {machine code} produced by {assemblers} or
	{compilers}.  It does not usually include the data processed
	by programs unless this is in a format such as {multimedia}
	which depends on the use of computers for its presentation.
	This distinction becomes unclear in cases such as {spread
	sheets} which can contain both instructions (formulae and
	{macros}) and data.  There are also various intermediate
	compiled or {semi-compiled}, forms of software such as
	{library} files and {byte-code}.

	Some claim that {documentation} (both paper and electronic) is
	also software.  Others go further and define software to be
	programs plus documentation though this does not correspond
	with common usage.

	The noun "program" describes a single, complete and
	more-or-less self-contained list of instructions, often stored
	in a single {file}, whereas "code" and "software" are
	uncountable nouns describing some number of instructions which
	may constitute one or more programs or part thereof.  Most
	programs, however, rely heavily on various kinds of {operating
	system} software for their execution.  The nounds "code" and
	"software" both refer to the same thing but "code" tends to
	suggest an interest in the implementation details whereas
	"software" is more of a user's term.

	(2002-07-21)

compiled and run

<operating system, programming> The process of carrying out
	the {instructions} in a computer program by a computer.

	See also {dry run}.

	(1996-05-13)

, but I got a warning on that,
and I was wondering what that means? In my program, I used Stringtokenizer
and stack

<programming> (See below for synonyms) A data structure for
	storing items which are to be accessed in last-in first-out
	order.

	The operations on a stack are to create a new stack, to "push"
	a new item onto the top of a stack and to "pop" the top item
	off.  Error conditions are raised by attempts to pop an empty
	stack or to push an item onto a stack which has no room for
	further items (because of its implementation).

	Most processors include support for stacks in their
	{instruction set architectures}.  Perhaps the most common use
	of stacks is to store {subroutine} arguments and return
	addresses.  This is usually supported at the {machine code}
	level either directly by "jump to subroutine" and "return from
	subroutine" instructions or by {auto-increment} and
	auto-decrement {addressing modes}, or both.  These allow a
	contiguous area of memory to be set aside for use as a stack
	and use either a special-purpose {register} or a general
	purpose register, chosen by the user, as a {stack pointer}.

	The use of a stack allows subroutines to be {recursive} since
	each call can have its own calling context, represented by a
	stack frame or {activation record}.  There are many other
	uses.  The programming language {Forth} uses a data stack in
	place of variables when possible.

	Although a stack may be considered an {object} by users,
	implementations of the object and its access details differ.
	For example, a stack may be either ascending (top of stack is
	at highest address) or descending.  It may also be "full" (the
	stack pointer points at the top of stack) or "empty" (the
	stack pointer points just past the top of stack, where the
	next element would be pushed).  The full/empty terminology is
	used in the {Acorn Risc Machine} and possibly elsewhere.

	In a list-based or {functional language}, a stack might be
	implemented as a {linked list} where a new stack is an empty
	list, push adds a new element to the head of the list and pop
	splits the list into its head (the popped element) and tail
	(the stack in its modified form).

	At {MIT}, {pdl} used to be a more common synonym for stack,
	and this may still be true.  {Knuth} ("The Art of Computer
	Programming", second edition, vol. 1, p. 236) says:

	  Many people who realised the importance of stacks and queues
	  independently have given other names to these structures:
	  stacks have been called push-down lists, reversion storages,
	  cellars, dumps, nesting stores, piles, last-in first-out
	  ("LIFO") lists, and even yo-yo lists!

	[{Jargon File}]

	(1995-04-10)

to reverse a string

<programming> A sequence of {data} values, usually {bytes},
	which usually stand for {characters} (a "character string").
	The {mapping} between values and characters is determined by
	the {character set} which is itself specified implcitly or
	explicitly by the environment in which the string is being
	interpreted.

	The most common character set is {ASCII} but, since the late
	1990s, there has been increased interest in larger character
	sets such as {Unicode} where each character is represented by
	more than eight {bits}.

	Most programming languages consider strings (e.g.
	"124:shabooya:\n", "hello world") basically distinct from
	numbers which are typically stored in fixed-length {binary} or
	{floating-point} representation.

	A {bit string} is a sequence of {bits}.

	(1999-12-21)

, and I think it has to do with stack?

also how can I recompile with -Xlint ?

Note:StackReverse.JAVA uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.

Process completed.

From: Lew

Date: Thursday, March 29, 2007

wrote in message

In {object-oriented programming} sending a message to an
	{object} (to invoke a {method}) is equivalent to calling a
	{procedure} in traditional programming languages, except that
	the actual code executed may only be selected at run time
	depending on the {class} of the object.  Thus, in response to
	the message "drawSelf", the method code invoked would be
	different if the target object were a circle or a square.

	(1995-02-16)

As you can see, My program compiled and run, but I got a warning on that,

We can not see what you do not show.

and I was wondering what that means? In my program, I used Stringtokenizer

Are you referring to StringTokenizer? If not, you'll need to give us a link

1. <file system> {hard link} or {symbolic link}.

	2. <hypertext> {hyperlink}.

	(1997-10-22)

to the docs for what you are talking about. If so, you'll need to spell

Any particularly arbitrary or obscure command that one must
	mutter at a system to attain a desired result.  Not used of
	passwords or other explicit security features.  Especially
	used of tricks that are so poorly documented that they must be
	learned from a {wizard}.  "This compiler normally locates
	initialised data in the data segment, but if you {mutter} the
	right incantation they will be forced into text space."

it
correctly for it to compile.

and stack to reverse a string, and I think it has to do with stack?

What stack implementation are you using?

also how can I recompile with -Xlint ?

Add the -Xlint option

<software> (Or "option", "flag", "switch", "option switch") An
	argument to a command that modifies its function rather than
	providing data.  Options generally start with "-" in {Unix} or
	"/" in {MS-DOS}.  This is usually followed by a single letter
	or occasionally a digit.

	Some commands require each option to be a separate argument,
	introduced by a new "-" or "/", others allow multiple option
	letters to be concatenated into a single argument with a
	single "-" or "/", e.g. "ls -al".  A few Unix commands
	(e.g. {ar}, {tar}) allow the "-" to be omitted.  Some options
	may or must be followed by a value, e.g. "cc prog.c -o prog",
	sometimes with and sometimes without an intervening space.

	{getopt} and {getopts} are commands for parsing command line
	options.  There is also a {C} library routine called getopt
	for the same purpose.

	(1996-12-11)

to your 'JAVAc' command

<operating system> A character string which tells a program to
	perform a specific action.  Most commands take {arguments}
	which either modify the action performed or supply it with
	input.  Commands may be typed by the user or read from a file
	by a {command interpreter}.  It is also common to refer to
	menu items as commands.

	(1997-06-21)

line.

Note:StackReverse.JAVA uses unchecked or unsafe operations.

This error

1. A discrepancy between a computed, observed, or measured
	value or condition and the true, specified, or theoretically
	correct value or condition.

	2. <programming> A mental mistake made by a programmer that
	may result in a program {fault}.

	3. (verb) What a program does when it stops as result of a
	programming error.

	(2000-03-28)

message comes from using "raw type

<theory, programming> (Or "data type") A set of values from
	which a {variable}, {constant}, {function}, or other
	{expression} may take its value.  A type is a classification
	of data that tells the {compiler} or {interpreter} how the
	programmer intends to use it.  For example, the process and
	result of adding two variables differs greatly according to
	whether they are integers, floating point numbers, or strings.

	Types supported by most programming languages include
	{integers} (usually limited to some range so they will fit in
	one {word} of storage), {Booleans}, {floating point numbers},
	and characters.  {Strings} are also common, and are
	represented as {lists} of characters in some languages.

	If s and t are types, then so is s -> t, the type of
	{functions} from s to t; that is, give them a term of type s,
	functions of type s -> t will return a term of type t.

	Some types are {primitive} - built-in to the language, with no
	visible internal structure - e.g. Boolean; others are
	composite - constructed from one or more other types (of
	either kind) - e.g. {lists}, {arrays}, {structures}, {unions}.
	{Object-oriented programming} extends this with {classes}
	which encapsulate both the structure of a type and the
	operations that can be performed on it.

	Some languages provide {strong typing}, others allow {implicit
	type conversion} and/or {explicit type conversion}.

	(2003-12-22)

s", that is, non-generic forms

1. <programming> {fill-out form}.

	2. <library> (Xforms) A {GUI} component library for {X11}.

	(1998-03-24)

for classes that were declared generic.

Note: Recompile with -Xlint:unchecked for details.

This compiler

<programming, tool> A program that converts another program
	from some {source language} (or {programming language}) to
	{machine language} (object code).  Some compilers output
	{assembly language} which is then converted to {machine
	language} by a separate {assembler}.

	A compiler is distinguished from an assembler by the fact that
	each input statement does not, in general, correspond to a
	single machine instruction or fixed sequence of instructions.
	A compiler may support such features as automatic allocation
	of variables, arbitrary arithmetic expressions, control
	structures such as FOR and WHILE loops, variable {scope},
	input/ouput operations, {higher-order functions} and
	{portability} of source code.

	{AUTOCODER}, written in 1952, was possibly the first primitive
	compiler.  {Laning and Zierler}'s compiler, written in
	1953-1954, was possibly the first true working algebraic
	compiler.

	See also {byte-code compiler}, {native compiler}, {optimising
	compiler}.

	(1994-11-07)

option will turn those warnings into specific errors.

Process completed.

But yours is not. You've provided no SSCCE, and a real

1. Not simulated.  Often used as a specific antonym to
	{virtual} in any of its jargon senses.

	2. <mathematics> {real number}.

	[{Jargon File}]

	(1997-03-12)

dearth of details.
There is not enough information here to give any kind of detailed help.

-- Lew

From: Jeremy

Date: Thursday, March 29, 2007

I commented out every block

1. <unit> A unit of data or memory, often, but not
	exclusively, on a {magnetic disk} or {magnetic tape}.

	Compare {record}, {sector}.

	(2000-07-17)

	2. <operating system> To delay or sit idle while waiting for
	something.

	Compare {busy-wait}.

	(2000-07-17)

	3. <programming> A delimited section of {source code} in a
	{block-structured} language.

	(2004-09-29)

of the code

<software> Instructions for a computer in some programming
	language, often {machine language}.  The word "code" is often
	used to distinguish instructions from {data} (e.g. "The code
	is marked 'read-only'") whereas "{software}" is used in
	contrast with "{hardware}" and may consist of more than just
	code.

	(2000-04-08)

, and I found out this section of
the code was the reason why I got a warning from the compiler.
String text

1. Executable code, especially a "pure code" portion shared
	between multiple instances of a program running in a
	{multitasking} {operating system}.

	Compare {English}.

	2. Textual material in the mainstream sense; data in ordinary
	{ASCII} or {EBCDIC} representation (see {flat ASCII}).  "Those
	are text files; you can review them using the editor."

	These two contradictory senses confuse hackers too.

	[{Jargon File}]

	(1995-03-16)

= "ABC stands for Another Bad Creation found in early
1990's";
Stack stack = new Stack();

// this statement will break

1. To cause to be {broken} (in any sense).  "Your latest patch
	to the editor broke the paragraph commands."

	2. (Of a program) To stop temporarily, so that it may
	debugged.  The place where it stops is a "{breakpoint}".

	3. To send an {EIA-232} break (two character widths of line
	high) over a {serial line}.

	4. [Unix] To strike whatever key currently causes the tty
	driver to send SIGINT to the current process.  Normally,
	break, delete or {control-C} does this.

	5. "break break" may be said to interrupt a conversation (this
	is an example of verb doubling).  This usage comes from radio
	communications, which in turn probably came from landline
	telegraph/teleprinter usage, as badly abused in the Citizen's
	Band craze a few years ago.

	6. {pipeline break}.

	7. {break statement}.

	[{Jargon File}]

	(2004-03-24)

the string into the words which are
separated by space.
StringTokenizer temp = new StringTokenizer(text);<--- is this the
culprit?

// push

1. <programming> To put something onto a {stack} or {pdl}.

	Opposite: "{pop}".

	2. <communications> {push media}.

	[{Jargon File}]

	(1997-04-10)

all the words to the stack one by one
while (temp.hasMoreTokens())
{
stack.push(temp.nextElement());
}
I'm using JCreater LE and It basically just run and compile the program
wrote in message:

As you can see, My program compiled and run, but I got a warning on that,
We can not see what you do not show.
and I was wondering what that means? In my program, I used
Stringtokenizer
Are you referring to StringTokenizer? If not, you'll need to give us a
link to the docs for what you are talking about. If so, you'll need to
spell it correctly for it to compile.
and stack to reverse a string, and I think it has to do with stack?
What stack implementation are you using?
also how can I recompile with -Xlint ?
Add the -Xlint option to your 'JAVAc' command line.
Note:StackReverse.JAVA uses unchecked or unsafe operations.
This error message comes from using "raw types", that is, non-generic
forms for classes that were declared generic.
Note: Recompile with -Xlint:unchecked for details.
This compiler option will turn those warnings into specific errors.
Process completed.
But yours is not. You've provided no SSCCE, and a real dearth of details.
There is not enough information here to give any kind of detailed help.

> -- Lew

From: Bart Cremers

Date: Friday, March 30, 2007

wrote in message:

I commented out every block of the code, and I found out this section of
the code was the reason why I got a warning from the compiler.
String text = "ABC stands for Another Bad Creation found in early
1990's";
Stack stack = new Stack();
// this statement will break the string into the words which are
separated by space.
StringTokenizer temp = new StringTokenizer(text);<--- is this the
culprit?
// push all the words to the stack one by one
while (temp.hasMoreTokens())
{
stack.push(temp.nextElement());
}
I'm using JCreater LE and It basically just run and compile the program
from the software, instead of command line.
wrote in message

wrote in message:
As you can see, My program compiled and run, but I got a warning on that,
> We can not see what you do not show.
and I was wondering what that means? In my program, I used
Stringtokenizer
> Are you referring to StringTokenizer? If not, you'll need to give us a
> link to the docs for what you are talking about. If so, you'll need to
> spell it correctly for it to compile.
and stack to reverse a string, and I think it has to do with stack?
> What stack implementation are you using?
also how can I recompile with -Xlint ?
> Add the -Xlint option to your 'JAVAc' command line.
Note:StackReverse.JAVA uses unchecked or unsafe operations.
> This error message comes from using "raw types", that is, non-generic
> forms for classes that were declared generic.
Note: Recompile with -Xlint:unchecked for details.
> This compiler option will turn those warnings into specific errors.
Process completed.
> But yours is not. You've provided no SSCCE, and a real dearth of details.
> There is not enough information here to give any kind of detailed help.
> -- Lew

The error message comes from using the stack without defining the
generic type of the stack. To get information about this when
compiling the compiler tells you to recompile using the option, so
JAVA -Xlint:unchecked ...

You can easily solve this (but you do not have to, as it is simply a
warning) two ways. Add the annotation

1. <programming, compiler> Extra information associated with a
	particular point in a document or program.  Annotations may be
	added either by a {compiler} or by the programmer.  They are
	not usually essential to the correct function of the program
	but give hints to improve performance.

	2. <hypertext> A new commentary {node} linked to an existing
	node.  If readers, as well as authors, can annotate nodes,
	then they can immediately provide feedback if the information
	is misleading, out of date or plain wrong.

	(1995-11-26)

@xxxxxxxxxxx("unchecked")
to the method

<programming> The name given in {Smalltalk} and other
	{object-oriented languages} to a procedure or routine
	associated with one or more {classes}.  An {object} of a
	certain class knows how to perform actions, e.g. printing
	itself or creating a new instance of itself, rather than the
	function (e.g. printing) knowing how to handle different types
	of object.

	Different classes may define methods with the same name
	(i.e. methods may be {polymorphic}).  The term "method" is used
	both for a named operation, e.g. "PRINT" and also for the code
	which a specific class provides to perform tha
	t operation.

	Most methods operate on objects that are instances of a
	certain class.  Some object-oriented languages call these
	"object methods" to distinguish then from "{class methods}".

	In {Smalltalk}, a method is defined by giving its name,
	documentation, temporary local variables and a sequence of
	expressions separated by "."s.

	(2000-03-22)

containing the violating code, or infer generic type
arguments on the stack:

Stack<String> stack = new Stack<String>();

Using this you can only add Strings to the stack (enforced at compile
time) and retrieving Strings from the stack can be done without
casting.

Regards,

Bart

Next Message: Little problem with class-variable acces

Blogs related to Compiler warning Question

Java Faqs
6) What are the two parts in executing a Java program and their purposes? Ans: Two parts in executing a Java program are: Java Compiler and Java Interpreter. The Java Compiler is used for compilation and the Java Interpreter is used for ...

.Net Interview Questions-VI
Conclusion. C# is not Java. Only methods in base classes need not override or hide derived methods. All methods in derived classes require to be either defined as new or as override. Know what your doing and look out for compiler warnings.

Java 7 Roundup (Feb 28th)
... annotations specifically for software defect detection. These annotations let you more precisely state the semantics of your code so that the compiler or automated tools could check those semantics and indicate warnings or errors. ...

comp.compilers monthly message and Frequently Asked Questions
The download area of the JavaCC (Java Compiler Compiler) site at https://javacc.dev.java.net/ BSD license) has a folder containing a number of grammars. * Where can I get free versions of yacc and lex ? Vern Paxton's flex is a superior ...

Invasion Of The Dynamic Language Weenies
Therefore I prefer a statically typed language, because I've found that compiler warnings about type mismatches are generally a sign that I've made some programmatic or conceptual error. I haven't written what I intended to. ...

Follow-up on the Java Generics post
I wonder if your compiler of choice makes a difference? I seem to remember Eclipse's JDT compiler having subtle differences from Sun's in regards to edge-case generics/casting scenarios (Sun's being more strict and giving more warnings) ...