Thread: Reusing code blocks for different variables

First of all, it would have been better if you posted that in the beginning. My earlier answer is now completely useless.

> I initially thought char** would work, but I was hoping that there was something like an enum or a case switch which would serve my purpose better
Maybe they do. What is your purpose?

As far as your code goes, there's not much you can do to make it shorter I think. This is because you do different things with the memory when the condition changes. You can make it easier to read.

> if ((tmp = realloc(source, sizeof(char) * (strlen(source) + 2))) == NULL)
Personally I don't like seeing things like this, when you can normally call memory allocators in one statement and then examine the pointer.

> strncat(source, (char*)current_char, sizeof(char));
This appends one character, and the cast doesn't look necessary from what you've posted.

> strncat(source, user, size * sizeof(char));
Multiplication is unnecessary, since size * sizeof(char) = size.

It sounds like you're parsing text to obtain words. There are much simpler ways to do it.
http://www.daniweb.com/code/snippet318.html

I also suggest that you look at the page for realloc. There are some things you should know about it before using it at random:
http://www.daemon-systems.org/man/realloc.3.html

> Are there any downsides to doing that?
I wouldn't use strncat the way that you are, because strncat expects a \0 terminated string, and this is not what you provide. It's purpose is to squish strings together, not append single characters to strings. To do that you can access the string itself. Probably source[oldlen] = *current_char;

> I know that sizeof(char) == 1, but what if that's not the case in the future?
The char data type has always been one byte long since I started programming, and is very likely to stay that way. Rather than changing the size of char and breaking legacy code, wider characters have their own data types.

Originally Posted by citizen

It sounds like you're parsing text to obtain words. There are much simpler ways to do it.
http://www.daniweb.com/code/snippet318.html

I took a look at the strcspn function and now have 2 questions.

1. How do I pass in all whitespace as the delimiter? Basically, instead of just specifying " ", I also want to account for " " (2 spaces) or "\t".
2. In my current parsing algorithm, I don't even want to parse anything beyond the second word unless both the first and second words satisfy certain conditions. Therefore, if both fail the specified condition, I just skip the rest of the parse. How can I use strcspn to take that into account? Or if it can't, would I just use the "source[oldlen] = *current_char" method?
3. As you might notice in my second post, I traversed character by character so that I could strncat *user to *source whenever *current_char == "&". If I were to switch to a strcspn method, how could I implement that functionality without retraversing the string again and replacing (with regex or some equivalent)?

If you want fined-tuned parsing, you should go make your own parser (maybe based on FSM). Then you can implement switches and special goodies to your heart's content.

Could you please define FSM for me?

google("c programming FSM")[0] = http://safari.oreilly.com/0131774298/ch08lev1sec6

FSM = Finite State Machine

Originally Posted by Queue

I took a look at the strcspn function and now have 2 questions.

1. How do I pass in all whitespace as the delimiter? Basically, instead of just specifying " ", I also want to account for " " (2 spaces) or "\t".
2. In my current parsing algorithm, I don't even want to parse anything beyond the second word unless both the first and second words satisfy certain conditions. Therefore, if both fail the specified condition, I just skip the rest of the parse. How can I use strcspn to take that into account? Or if it can't, would I just use the "source[oldlen] = *current_char" method?
3. As you might notice in my second post, I traversed character by character so that I could strncat *user to *source whenever *current_char == "&". If I were to switch to a strcspn method, how could I implement that functionality without retraversing the string again and replacing (with regex or some equivalent)?

That code is suited to single-character delimiters, although more than one delimiter may be used (any one character).

For multiple whitespace as a delimiter, I might do something with pointers and isspace. Start at the beginning; move the end to the whitespace and then the end minus the start is the length; (do something); move the start to the beginnig of the whitespace (the end), then eat the spaces and move the end; lather, rinse, repeat.

Code:

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

void parse(const char *text)
{
   const char *end = text, *start = text;
   while ( *start != '\0'  )
   {
      while ( *end != '\0' && !isspace(*end) )
      {
         ++end;
      }
      /*
       * Do stuff.
       */
      printf("\"%.*s\"\n", end - start, start);
      /*
       * Move the start and end pointers.
       */
      start = end;
      while ( *start != '\0' && isspace(*start) )
      {
         ++start;
      }
      end = start;
   }
}

int main(void)
{
   const char *line[] = { "text1  text2 \t text3", " text1\rtext2\n", "" };
   size_t j;
   for ( j = 0; j < sizeof line / sizeof *line; ++j )
   {
      puts("---");
      parse(line[j]);
   }
   return 0;
}

/* my output
---
"text1"
"text2"
"text3"
---
""
"text1"
"text2"
---
*/

Hm. I dunno about a full-fledged FSM for this, I've never written a complex parser. Some ideas...

Code:

#include <stdio.h>
#include <ctype.h>
#include <string.h>

int myfunction(const char *text, int len)
{
   const char *comma = strchr(text, ',');
   if ( comma == NULL )
   {
      return 0;
   }
   printf("\"%.*s\"\n", len, text);
   fflush(stdout);
   return 1;
}

void parse(const char *text, int (*foo)(const char *, int len))
{
   const char *end = text, *start = text;
   while ( *start != '\0' )
   {
      while ( *end != '\0' && !isspace(*end) )
      {
         ++end;
      }
      /*
       * Do stuff.
       */
      if ( !foo(start, end -  start) )
      {
         break;
      }
      /*
       * Move the start and end pointers.
       */
      start = end;
      while ( *start != '\0' && isspace(*start) )
      {
         ++start;
      }
      end = start;
   }
}

int main(void)
{
   const char line[] = "user1,user2 group1,group2,group3 string1 string2 string3";
   parse(line, myfunction);
   return 0;
}

/* my output
"user1,user2"
"group1,group2,group3"
*/

Some example of checking for a comma.

But I don't think this fella is writing a whole new language; (s)he doesn't need a compiler-quality parser. Learning Flex/Bison/Yacc may take as much time as, if not more than, to just write a decent-quality string parser from scratch.