problem in calling a function converting string to lowercase using c [closed] - c

Question

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 3 years ago.
Improve this question
Below is the c code to kill a window in a versatile way.
When I call it in this way, it shows the message and then got stuck.
killWindowsVersatile.exe key ci ever 2 1000 "Super"
...closing window with argument:key,ci,ever,2,1000,Super,
name_key = 2;
cs_ci = 2;
ever_once = 1;
delay for 2 seconds start...
remaining 2 seconds ...
remaining 1 seconds ...
remaining 0 seconds ...
entering ever mode
Below is the code of the file:
It kills window either by name or a key word, and can delay for seconds, and can be case sensitive or insensitive. It can also loop the command by itself in a interval time of spacing.
There may be something wrong in the to_lowercase function.
#include <stdio.h>
#include <stdlib.h>
#define WINVER 0x0600
#define _WIN32_IE 0x0500
#include <windows.h>
#include <stdint.h>
#include <ctype.h>
int name_key,cs_ci,ever_once,delay;
//the order of function is important! you cannot call something before defined !
const char * to_lowercase(char* str){
int len = strlen(str);
char * newStr[len];
for(int i = 0; str[i]; i++){
newStr[i] = tolower(str[i]);
}
return newStr;
}
BOOL CALLBACK WindowFoundCB(HWND hwnd, char* param){
char *key = (char*) param;
char title[256]; // This way, you have allocated 256 bytes for the Window name.
GetWindowText(hwnd, title, 256);
HWND me = GetConsoleWindow();
if (IsWindowVisible(hwnd) && hwnd != me){
if(cs_ci==1){
char *p = strstr(title,key);
if (p!= NULL){
SendMessage(hwnd, WM_SYSCOMMAND, SC_CLOSE, 0);
printf("==== close a window by key [%s]: <%s>\n",key,title);
}
}else if(cs_ci==2){
char title_lower[256];
char key_lower[256];
strcpy(title_lower,to_lowercase(title));
strcpy(key_lower,to_lowercase(key));
//char *title_lower = to_lowercase(title);
//char *key_lower = to_lowercase(key);
char *p = strstr(title_lower,key_lower);
if (p!= NULL){
SendMessage(hwnd, WM_SYSCOMMAND, SC_CLOSE, 0);
printf("==== close a window by key [%s]: <%s>\n",key,title);
}
}
}
return TRUE;
}
int dealwithonce(int name_key,int cs_ci,char *argv[],int argc){
for(int i = 6; i < argc; i++){
if(name_key == 1){
HWND hwnd = FindWindow(NULL, argv[i]);
if(hwnd){
char strIte[256]; // This way, you have allocated 256 bytes for the Window name.
GetWindowText(hwnd, strIte, 256);
if( (cs_ci==2) || ((cs_ci==1)&& !strcmp(strIte,argv[i])) ){
SendMessage(hwnd, WM_SYSCOMMAND, SC_CLOSE, 0);
printf("==== close a window by name [%s]\n",argv[i]);
}
}
}else if(name_key == 2){
char* aStr = argv[i];
EnumWindows(WindowFoundCB,aStr);
}
}
}
int main(int argc, char *argv[])
{
// argumrnt check
printf("...closing window with argument:");
for(int i = 1; i < argc; i++){
printf("%s,", argv[i]);
}
printf("\n");
// argument parse
if(argc < 7){
printf("%s\n","you must input 5 arguments at least!");
printf("%s\n","arg1: [name] or [key]");
printf("%s\n","arg2: [cs] for case-sensitive or [ci] for case-insensitive");
printf("%s\n","arg3: [ever] for forever or [once] for once");
printf("%s\n","arg4: the seconds for delay before start., 0,1,2...");
printf("%s\n","arg5: the milliseconds of Cycle for ever mode., 1,2,500,1000,...");
printf("%s\n","arg6+: the assembly of any strings");
return 0;
};
if(!strcmp(argv[1],"name")){
printf("name_key = 1;\n");
name_key = 1;
}else if(!strcmp(argv[1],"key")){
printf("name_key = 2;\n");
name_key = 2;
}
if (!strcmp(argv[2],"cs")){
printf("cs_ci = 1;\n");
cs_ci = 1;
}else if(!strcmp(argv[2],"ci")){
printf("cs_ci = 2;\n");
cs_ci = 2;
}
if (!strcmp(argv[3],"ever")){
printf("ever_once = 1;\n");
ever_once = 1;
}else if(!strcmp(argv[3],"once")){
printf("ever_once = 2;\n");
ever_once = 2;
}
// delay
delay = atoi(argv[4]);
if(delay > 0){
printf("delay for %d seconds start...\n",delay);
for(int i=delay;i>=0;i--){
printf("remaining %d seconds ...\n",i);
Sleep(1000);
}
}
//cycle
int interval = atoi(argv[5]);
// ever or not
if(ever_once == 1){
printf("entering ever mode\n");
while(1){
dealwithonce(name_key,cs_ci,argv,argc);
Sleep(interval);
}
}else if(ever_once == 2){
printf("entering once mode\n");
dealwithonce(name_key,cs_ci,argv,argc);
}
return 0;
}

Answer 1

strcmp returns a value that represents how argument 1 compares to argument 2 alphabetically. If they are equal, it returns 0 which is numerically equivalent to the false boolean. Thus you need to modify your if statements like this:
if(!strcmp(argv[1],name)){
printf("name_key = 1;");
name_key = 1;
}else if(!strcmp(argv[1],key)){
printf("name_key = 2;");
name_key = 2;
}
if (!strcmp(argv[2],cs)){
printf("cs_ci = 1;");
cs_ci = 1;
}else if(!strcmp(argv[2],ci)){
printf("cs_ci = 2;");
cs_ci = 2;
}
if (!strcmp(argv[3],ever)){
printf("ever_once = 1;");
ever_once = 1;
}else if(!strcmp(argv[3],once)){
printf("ever_once = 2;");
ever_once = 2;
}
This way if the two strings are equivalent alphabetically, then strcmp will return 0 which will be negated to assume the value of true and the program execution will enter the if block. If the two strings are NOT equal, then strcmp will return either a positive or a negative value which is equivalent to the boolean true. Negating this will assume the value of false and the program execution will not enter the if block.
Hope this helps!
EDIT:
To help you understand why your to_lowercase function might not be working properly, you have to understand two things about arrays:
Firstly, the array contents are not passed to the function. The C language (and thus all compilers/interpreters) only passes the single value of any variable to a function when it is called. In this case, the array only contains the memory address of the first element of the array. That address is passed to the function instead of the array as a whole.
Secondly, an array declaration is simply a pointer to the first location of a contiguous set of locations in memory. When you reference the first element of an array you are accessing the first memory location pointed to by the pointer. When you reference the second, third, or even fourth element of the array, you are accessing the locations in memory that are exactly 2 or 3 or even 4 memory locations away from the first element.
So what can we do with this? What happens when we change the values pointed to by the pointer? Remember, when you modify an array, (without intervention of some memory allocation tricks) the memory locations pointed to by the pointer do not change. Only the values in those memory locations change. This is why we cannot copy arrays by simply typing: array1 = array2. All this is doing is copying the pointer in array2 to array1. Any modifications you make to array2 will have a side effect of also being made in array1 because they both now point to the same locations in memory!
So if you think you have an error in your to_lowercase function, try this modification to it. I cannot test your complete code because my GCC compiler is for Linux, but it should work for you:
void to_lowercase(char *str)
{
for(int i = 0; str[i]; i++)
{
str[i] = tolower(str[i]);
}
}
HOW DOES THIS WORK?
When we pass an array to a function, we are passing the value of the array pointer. Thus the function only receives a location in memory. By utilizing this pointer, we can advance through memory to the other locations pointed to by that pointer (via str[i]) and modify them freely without affecting the value of the pointer itself.
Hope this helps.

Answer 2

You're correct - your to_lowercase function is doing multiple things wrong:
The way this function is currently written newStr is defining an array of char *, not an array of char.
You're then returning newStr, which is an automatic variable defined on the stack. As soon as the function returns newStr is subject to being overwritten by any other subroutine calls which are made.
You could choose to define to_lowercase as
const char * to_lowercase(char* str){
char *newStr = malloc(strlen(str)+1);
for(int i = 0; str[i]; i++)
newStr[i] = tolower(str[i]);
return newStr;
}
but this means that you'd have to be careful to free the memory allocated in to_lowercase each time you use it.
A better idea might be to write to_lowercase in such a manner that it changes the string it's passed to lower case in-place:
char *to_lowercase(char* str){
for(char *p = str; *p; p++)
*p = tolower(*p);
return str;
}
This overwrites the original content of str so you'll need to be sure to account for that in your code.