Warnings

Warnings

blitzcc points out code that is legal but probably not what was meant. A warning looks like an error, names the option that controls it, and often adds a notice: line that says how to fix it:

program.bb:1:12: warning: Implicit conversion from Float32 to Int32, the fractional part is lost. [-Wimplicit-lossy-real-to-int]
Local i% = 2.5
           ^^^ HERE
notice: Use Int(value) to convert on purpose, or SatInt(value) to stop at the limits of Int32.

The carets under the line cover the part of the code the message is about (a single one when it is a point), and the dashes after them reach to the end of the line. A notice is also a warning that is only a hint, such as a variable that is never used; its first line says notice: instead of warning:.

Warnings about implicit conversions name both types, with their long names (Int8 to Int64, UInt8 to UInt64, Float16, Float32, Float64 and String), and the notice: line names the function that converts on purpose: Int, Float, Str, Byte, UShort, Long, Double and so on, and for whole numbers also the Sat version (SatInt, SatByte, ...) that stops at the limits instead of wrapping around.

Warnings never stop the compilation, unless they are turned into errors with -Werror. Errors (a program that can not be compiled) always stop it, and are printed as file:line:column: error: ... with the same source line display.

Blitz-Tidy fixes most of these warnings in your source files for you.

Levels

-W0 to -W4 choose how many warnings there are: each level has all the warnings of the levels below it. -W2 is the default.

Level	Meaning
-W0	No warnings.
-W1	Code that loses information.
-W2	Likely mistakes (default).
-W3	Style, and notices about code that does nothing.
-W4	Declarations without a type, and notices about functions that are never called.

Options

Option	Effect
-W0 ... -W4	Set the level.
-W<name>	Turn the warning <name> on, whatever the level is.
-Wno-<name>	Turn the warning <name> off, whatever the level is.
-Werror	Every warning that is on is an error: it is printed as error: ... [-Werror=<name>], the whole program is still checked, and then blitzcc fails. Notices are not turned into errors.
-Werror=<name>	Only the warning <name> (a notice too) is an error, and it is turned on if the level does not include it.
-Wno-error=<name>	The warning <name> stays a warning with -Werror.
-Wno-error	Cancel an earlier -Werror.

-W<name> and -Wno-<name> win over the level, and -Werror=<name> and -Wno-error=<name> win over -Werror, wherever on the command line they are. The options are not case sensitive. An unknown name is an error. -q hides warnings and notices (not the ones that are errors) and +q hides everything.

The warnings

Name	Level	Warns about
loop-type-mismatch	1	The start, end or step of a For loop has another type than the counter (For b:Byte = 0 To n with an Int). A value that does not fit in the counter can never be reached, so the loop may never end; a real number is rounded for an integer counter. A number written in the program that fits is fine.
literal-out-of-range	1	A whole number written without a suffix does not fit into an Int (Local x = 5000000000). Like in the original it is clamped to the largest Int (2147483647), and -2147483648 becomes -2147483647. Write i64 or ui64 (or ui32, i32) behind the number to keep it, see Number-Suffixes.
loop-iterator-type-unsafe	1	A For loop whose variable is a real number (Float, Half, Double). Reals do not count exactly, so the loop can run once more or less than expected, or never end.
large-local-array	1	A Local array in a function that takes more than 4 KiB (1024 Int entries), which has to be made and set to 0 again on every call; above 64 KiB it lives on the heap. Make it once with Global or Dim outside of the function. The main program is not checked.
implicit-lossy-int-to-int	1	An integer assigned or passed to an integer that is smaller or has another sign (Int to Byte, Int to UInt, ...), which can change the number. A number written in the program that fits is fine.
implicit-lossy-real-to-int	1	A Float assigned or passed to an integer (Local i% = 2.5). It is rounded, like in the original, and the fractional part is lost.
implicit-lossy-real-to-real	1	A real number assigned or passed to a smaller one (Double to Float).
implicit-string-to-number	1	A String assigned or passed to a number. It is 0 if it does not start with a number.
implicit-lossy-int-to-real	2	An integer assigned or passed to a real number that can not hold all its values (Int to Float, Long to Double).
implicit-variable	2	A variable that was never declared with Local, Global or Dim. Blitz makes it a local one, so this is legal.
return-missing-value	2	Return without a value in a function that was declared with a type (Function Name$(), Function Name:Float()). It returns 0, "" or Null. A function without a type is an Int by default, so it is left alone.
return-type-mismatch	2	Return gives a value of another type than the function was declared with (an Int in a function that returns a String, a Double in a Float one). Both types are named, with the conversion function that fixes it when there is one. A whole number written in the program that fits (Return 0 in a Float function) is fine. When this is on, it says what the implicit-* warnings would say for that Return.
implicit-number-to-string	3	A number assigned or passed to a String.
inout-parameter-unwritten	3	A path of a function (a Return, or the end) leaves without writing to one of its InOut parameters, so the variable of the caller stays as it was. For an Out parameter this is an error. See Parameter modes.
short-type-notation	3	A type written as a character behind the name (x%, x%%, x#, x##, x$) instead of the long form (x:Int32, x:Int64, x:Float32, x:Float64, x:String). The long form is the one the language is documented with. .TypeName has no other form and does not warn. blitz-tidy can rewrite it.
unreachable-code (notice)	3	A statement after Return, End, Goto or Exit in the same block, which can never run. Labels and Data do not count. Only the first one is reported.
unused-variable (notice)	3	A Local or Global variable that is never read (writing to it does not count). It is optimized away.
typeless-declaration	4	A Local, Global, Const, Dim, Function (its result), function parameter or Field without a type (Local x, Function Foo(a), Field size): it is an Int, which is not always what was meant. For a function the notice says which type its Return statements give (:Void if none gives a value).
loop-unroll-requires-constant	4	The Step of a For loop is not a constant, so the loop can not be unrolled. A constant step of 0 is an error.
unused-result	4	A function that returns a value is called as a statement, and the value is thrown away. Built-in and .decls functions without a result, and functions of the program that never Return a value, do not warn. A call in an expression, If or Select is a use.
unused-function (notice)	4	A function that is never called. It is optimized away.

blitzcc --help lists the same warnings.

Examples

blitzcc -W0 program.bb                  # no warnings at all
blitzcc -W4 -Werror -c program.bb       # strict: check the program, any warning fails (notices do not)
blitzcc -Werror -Wno-error=typeless-declaration program.bb   # fail on warnings, except for typeless-declaration
blitzcc -Wno-implicit-lossy-real-to-int program.bb    # the default level, without that warning
blitzcc -W4 -Werror=unused-function -c program.bb     # a notice that is an error

Installation · Differences