Letter conversion program for Ada - ada

Question

I made a letter conversion program in Ada that will take any lowercase letter and change it to uppercase and vice versa. The entire thing works until you get to my argument_count = 3 portion. Its supposed to output text to another file, and its just not working at all. My exception error when others=> error keeps popping up.
It's supposed to go something like this when you input it into terminal or command-line:
./case_converter u plain.text output
With Ada.Text_IO, Ada.Command_Line, Ada.Characters.Handling;
Use Ada.Text_IO, Ada.Command_Line, Ada.Characters.Handling;
Procedure case_conversion is
Argument_Error : Exception; --the excpetion raise for bad command-line arguments.
Input, Output : File_Type;-- input and output files, if specified.
File : File_Type;
Eol : Boolean;
Char : Character;
Function To_Upper (upper : Character) Return Character is
Begin
Case upper is
When 'a' =>
Return 'A';
When 'b' =>
Return 'B';
When 'c' =>
Return 'C';
When 'd' =>
Return 'D';
When 'e' =>
Return 'E';
When 'f' =>
Return 'F';
When 'g' =>
Return 'G';
When 'h' =>
Return 'H';
When 'i' =>
Return 'I';
When 'j' =>
Return 'J';
When 'k' =>
Return 'K';
When 'l' =>
Return 'l';
When 'm' =>
Return 'M';
When 'n' =>
Return 'N';
When 'o' =>
Return 'O';
When 'p' =>
Return 'P';
When 'q' =>
Return 'Q';
When 'r' =>
Return 'R';
When 's' =>
Return 'S';
When 't' =>
Return 'T';
When 'u' =>
Return 'U';
When 'v' =>
Return 'V';
When 'w' =>
Return 'W';
When 'x' =>
Return 'X';
When 'y' =>
Return 'Y';
When 'z' =>
Return 'Z';
When Others =>
Return char; -- This will let me know if there is a bug in the code, and to just return char.
end case;
end To_Upper;
Function To_Lower (lower : Character) Return character is
Begin
Case lower is
When 'A' =>
Return 'a';
When 'B' =>
Return 'b';
When 'C' =>
Return 'c';
When 'D' =>
Return 'd';
When 'E' =>
Return 'e';
When 'F' =>
Return 'f';
When 'G' =>
Return 'g';
When 'H' =>
Return 'h';
When 'I' =>
Return 'i';
When 'J' =>
Return 'j';
When 'K' =>
Return 'k';
When 'L' =>
Return 'l';
When 'M' =>
Return 'm';
When 'N' =>
Return 'n';
When 'O' =>
Return 'o';
When 'P' =>
Return 'p';
When 'Q' =>
Return 'q';
When 'R' =>
Return 'r';
When 'S' =>
Return 's';
When 'T' =>
Return 't';
When 'U' =>
Return 'u';
When 'V' =>
Return 'v';
When 'W' =>
Return 'w';
When 'X' =>
Return 'x';
When 'Y' =>
Return 'y';
When 'Z' =>
Return 'z';
When Others =>
Return char;
end case;
End To_Lower;
begin
If argument_count < 1 then
Raise Argument_Error;
end if;
IF Argument_Count > 1 THEN
null;
END IF;
IF Argument_Count > 2 THEN
null;
END IF;
If argument_Count = 1 then
loop
look_Ahead (Char, Eol);
if Argument (1) = "U" or Argument (1) = "u" then
Get (char);
Char := (To_Upper(char));
Put (char);
elsif
Argument (1) = "L" or Argument (1) = "l" then
Get (char);
Char := (To_Lower(char));
Put (char);
end if;
end loop;
end if;
-----------------------------------------------------------
If Argument_Count = 2 then
Open (file, In_File, Argument (2));
end if;
While Not End_of_File (file) loop
Look_Ahead (File, Char, EoL);
If Argument (1) = "U" or Argument (1) = "u" then
Get (file, char);
Char := (To_Upper(char));
Put (char);
elsif
Argument (1) = "L" or Argument (1) = "l" then
Get (file, char);
Char := (To_Lower(char));
Put (char);
end if;
If EoL then
New_Line;
end if;
end loop;
------------------------------------------------------------
If Argument_Count = 3 then
Open (file, In_File, Argument (2));
Create (Output, Out_file, Argument(3));
While Not End_of_File (file) loop
-- Look_Ahead (file, Char, EoL);
If EoL then
New_Line(output);
end if;
If Argument (1) = "U" or Argument (1) = "u" then
Get (file, char);
Char := (To_Upper(char));
Put (output, char);
elsif Argument (1) = "L" or Argument (1) = "l" then
---------
If Eol then
new_line (output);
end if;
Get (file, char);
Char := (To_Lower(char));
Put (output, char);
end if;
end loop;
end if;
IF Is_Open(input) THEN
Close(Input);
END IF;
IF Is_Open(Output) THEN
Close(Output);
END IF;
EXCEPTION
WHEN Name_Error =>
Put_Line("The file " & Argument(2) & " cannot be used for input");
WHEN OTHERS =>
Put_Line("Usage: case_converter U|L [infile [outfile]]");
end case_conversion;

Answer 1

Why not the Ada.Characters.Handling.To_Upper (and To_Lower) Function?
If you really need to check that the character is alphabetic use Is_Letter.

Answer 2

It's often a bad idea to catch exceptions with a when others, unless you're sure what exceptions might be raised (and even very experienced developers can get this wrong).
In your case, you should comment out the 'when others' lines; when you run your program and the exception occurs, it will be reported (usually with the line number where it happened, though not - on my machine - in this case). It helps to get a stack trace: this is harder on Mac OS X than on other machines, I wrote about it here.
I ran
$ ./case_conversion u case_conversion.adb t
Execution terminated by unhandled exception
Exception name: ADA.IO_EXCEPTIONS.STATUS_ERROR
Message: file not open
Call stack traceback locations:
0x1000103bc 0x10000c9eb 0x100001e9a 0x100001a19
and decoded the stack trace with
$ atos -o case_conversion 0x1000103bc 0x10000c9eb 0x100001e9a 0x100001a19
system__file_io__check_read_status (in case_conversion) (s-fileio.adb:207)
ada__text_io__end_of_file (in case_conversion) (a-textio.adb:304)
_ada_case_conversion (in case_conversion) (case_conversion.adb:177)
main (in case_conversion) (b~case_conversion.adb:265)
and looked at case_conversion.adb:177:
173 if Argument_Count = 2 then
174 Open (File, In_File, Argument (2));
175 end if;
176
177 while not End_Of_File (File) loop
So, what happens if Argument_Count is 3?
If you're not running on Mac OS X, instead of atos try addr2line.

Answer 3

Shark has it right BTW. Its silly not to use the built-in routine for this.
However, if you were to want to write it yourself for some weird reason, the fact that the letters are contiguous and in the same sequence for upper and lower makes the way you are going about it even sillier. Notice that every entry in those big honking case statements of yours are the same distrance from each other. To make each case entry, you could just copy the previous one and increase the value of both sides by one. This is the exact kind of repeated mechanical activity we invented computers to help us with, isn't it? :-)
The traditional way to covert between the two is to just add the difference between the two sets of characters in the collating sequence (most folks pick the letter 'A'). For example:
Upper_To_Lower_Difference : constant := character'pos('a') - character'pos('A');
function To_Upper (Lower : character) return character is
begin
if Lower in 'a'..'z' then
return character'val(character'pos(Lower) + Upper_To_Lower_Difference);
end if;
return Lower;
end To_Upper;