Please help...........

[Steve Clay]

I have a small C program for a college course. It is meant to encrypt
and decrypt lower case letters and leave spaces as spaces. I can't
get it to run properly as I think I have a problem in the While
construct area. It is driving me mad trying to sort it out - can
someone please help.

The program is:

/*
* Program to encrypt a message using the Turbo C random
* number generator. Only lower case letters and the space
* character can be used in the message.
*/

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <ctype.h>

#define SEED 1

unsigned char encrypt(unsigne d char);
unsigned char decrypt(unsigne d char);
void wait(void);
main()

{
unsigned char c;
char type;

/*
* initialise the random number generator
*/
srand(SEED);

/*
* display user headings and prompts
*/
clrscr();
cprintf("T223 encryption program\r\n\r\n ");
cprintf("Type d to decode a message or any other character to encode
");
type = getch(); /* input the user option */
cprintf("\r\nNo w type in the message, use only lower case letters "
"or space.\r\nEnd with any other character.\r\n\ r\n");
c = (unsigned char)getchar(); /* read in first character */

/*
* main encryption/decryption loop
* loop while characters are lower case letters or spaces
*/
while ((c>='a') && (c<='z') && (c=' '));
{
if (c==' ')
{
switch (type)
{
case '64':
c = decrypt (c) ;
break;

default:
c = encrypt (c) ;
break;
}
}
putchar('c'); /* display encrypted/decrypted character */
c = (unsigned char)getchar(); /* get next character */
}
/*
* end of main while loop
*/
wait();
}

/*
* end of main() function
*/
/*
* function encrypt()
* =============== ===
* encrypts a single character
*/
unsigned char encrypt(unsigne d char letter)
{
unsigned char r;
r = (unsigned char)random(26) ;
letter = letter + r;
if (letter>'z')
{
letter = letter - 26;
}
return(letter);
}
/*
* end of encrypt()
*/
/*
* function decrypt()
* =============== ===
* decrypts a single character
*/
unsigned char decrypt(unsigne d char letter)
{
unsigned char r;
r = (unsigned char)random(26) ;
letter = letter - r;
if (letter<'a')
{
letter = letter + 26;
}
return(letter);
}
/*
* end of decrypt()
*/
/*
* function wait()
* ===============
* waits for a keypress
*/

void wait(void)
{
fflush(stdin);
cprintf("\r\nPr ess return to terminate");
getchar();
}
/*
* end of wait()
*/
/*
* end of program
*/

[The Real OS/2 Guy]

On Wed, 25 Feb 2004 22:01:42 UTC, pete <pf*****@mindsp ring.com> wrote:

The Real OS/2 Guy wrote:

On Wed, 25 Feb 2004 14:01:38 UTC, pete <pf*****@mindsp ring.com> wrote:

I've got this:

#include <limits.h>
#include <string.h>

#define LOWER "abcdefghijklmn opqrstuvwxyz"

int islower(int c)
{
return CHAR_MAX >= c && c > '\0' && strchr(LOWER, c) != NULL;
}

try to test the strings

"MÄHMASCHIN E"
"mähen"
"büßen"
......

fails miserably on characters used by french, italian, german,
norways, .........
The world is not US only.

islower() works correctly on them when LC_LOCALE is set correctly.

I don't have LC_LOCALE in my version of N869.

Is it possible for a conforming implementation to only support
the "C" locale ?

Yes - but that limits you to be unable to NOT use national language
support and makes your program userunfriendly.

--
Tschau/Bye
Herbert

Visit http://www.ecomstation.de the home of german eComStation

[Dave Thompson]

On Wed, 25 Feb 2004 11:49:55 +0000, Richard Heathfield
<in*****@addres s.co.uk.invalid > wrote:

Michael wrote:

Hi Steve,
Peter already pointed out some problems
in your program (more I ever found). I
just want to add s.th. according your
while condition:

while ((c>='a') && (c<='z') && (c=' '));
Isn't it

> while ((c>='a') && (c<='z') || (c==' '))

a character 'or' space?

Well, that's certainly an improvement, since no character can be a letter
/and/ a space. But this:

Plus it (quietly) fixes the spurious null loop body.
while(islower(( unsigned char)c) || (c == ' '))
Although in general the cast is advisable, in the OP's code c is
(already) uchar, plus set from getchar which except for EOF (not
checked for) produces only uchar *values* though not uchar type.
is better still, since it doesn't rely on lower case letters being
contiguous and in alphabetical order.

Although the encrypt and decrypt functions, which you snipped, do.
Plus they rely on the codes for lowercase letters not being within 26
of either end of the range of unsigned char. Which does happen to be
the case for ASCII. And even for EBCDIC, which already failed the
contiguous criterion anyway, and doesn't satisfy that for *upper*case.

- David.Thompson1 at worldnet.att.ne t