Scan and swap string values with regex in ANSI C - c

Question

I want to transform a given input in my c program, for example:
foo_bar_something-like_this
into this:
thissomethingbarfoolike
Explanation:
Every time I get a _, the following text up to, but not including, the next _ or - (or the end of the line) needs to go to the beginning (and the preceding _ needs to be removed). Every time I get a -, the following text up to, but not including, the next _ or - (or the end of the line) needs to be appended to the end (with the - removed).
If possible, I would like to use regular expressions in order to achieve this. If there is a way to do this directly from stdin, it would be optimal.
Note that it is not necessary to do it in a single regular expression. I can do some kind of loop to do this. In this case I believe I would have to capture the data in a variable first and then do my algorithm.
I have to do this operation for every line in my input, each of which ends with \n.
EDIT: I had already written a code for this without using anything related to regex, besides I should have posted it in the first place, my apologies. I know scanf should not be used to prevent buffer overflow, but the strings are already validated before being used in the program. The code is the following:
#include <stdio.h>
#include <stdlib.h>
#define MAX_LENGTH 100001 //A fixed maximum amount of characters per line
int main(){
char c=0;
/*
*home: 1 (append to the start), 0 (append to the end)
*str: array of words appended to the begining
*strlen: length of str
*line: string of words appended to the end
*linelen: length of line
*word: word between a combination of symbols - and _
*wordlen: length of the actual word
*/
int home,strlen,linelen,wordlen;
char **str,*line,*word;
str=(char**)malloc(MAX_LENGTH*sizeof(char*));
while(c!=EOF && scanf("%c",&c)!=EOF){
line=(char*)malloc(MAX_LENGTH);
word=(char*)malloc(MAX_LENGTH);
line[0]=word[0]='\0';
home=strlen=linelen=wordlen=0;
while(c!='\n'){
if(c=='-'){ //put word in str and restart word to '\0'
home=1;
str[strlen++]=word;
word=(char*)malloc(MAX_LENGTH);
wordlen=0;
word[0]='\0';
}else if(c=='_'){ //put word in str and restart word to '\0'
home=0;
str[strlen++]=word;
word=(char*)malloc(MAX_LENGTH);
wordlen=0;
word[0]='\0';
}else if(home){ //append the c to word
word[wordlen++]=c;
word[wordlen]='\0';
}else{ //append c to line
line[linelen++]=c;
line[linelen]='\0';
}
scanf("%c",&c); //scan the next character
}
printf("%s",word); //print the last word
free(word);
while(strlen--){ //print each word stored in the array
printf("%s",str[strlen]);
free(str[strlen]);
}
printf("%s\n",line); //print the text appended to the end
free(line);
}
return 0;
}

Answer 1

I do not think regex can do what you are asking for, so I wrote a simple state machine solution in C.
//
//Discription: This Program takes a string of character input, and parses it
//using underscore and hyphen as queue to either send data to
//the begining or end of the output.
//
//Date: 11/18/2017
//
//Author: Elizabeth Harasymiw
//
#include <stdio.h>
#include <string.h>
#define MAX_SIZE 100
typedef enum{ AppendEnd, AppendBegin } State; //Used to track either writeing to begining or end of output
int main(int argc,char**argv){
char ch; //Used to hold the character currently looking at
State state=AppendEnd; //creates the State
char Buffer[MAX_SIZE]={}; //Current Ouput
char Word[MAX_SIZE]={}; //Pending data to the Buffer
char *c; //Used to index and clear Word
while((ch = getc(stdin)) != EOF){
if(ch=='\n')continue;
switch(state){
case AppendEnd:
if( ch == '-' )
break;
if( ch == '_'){
state = AppendBegin; //Change State
strcat(Buffer, Word); //Add Word to end of Output
for(c=Word;*c;c++)*c=0; //Clear Word
break;
}
{
int postion = -1;
while(Word[++postion]); //Find end of Word
Word[postion] = ch; //Add Character to end of Word
}
break;
case AppendBegin:
if( ch == '-' ){
state = AppendEnd; //Change State
strcat(Word, Buffer); //Add Output to end of Word
strcpy(Buffer, Word); //Move Output from Word back to Output
for(c=Word;*c;c++)*c=0; //Clear Word
break;
}
if( ch == '_'){
strcat(Word, Buffer); //Add Output to end of Word
strcpy(Buffer, Word); //Move Output from Word back to Output
for(c=Word;*c;c++)*c=0; //Clear Word
break;
}
{
int postion = -1;
while(Word[++postion]); //Find end of Word
Word[postion] = ch; //Add Character to end of Word
}
break;
}
}
switch(state){ //Finish adding the Last Word Buffer to Output
case AppendEnd:
strcat(Buffer, Word); //Add Word to end of Output
break;
case AppendBegin:
strcat(Word, Buffer); //Add Output to end of Word
strcpy(Buffer, Word); //Move Output from Word back to Output
break;
}
printf("%s\n", Buffer);
}

Answer 2

This can be done with regexes using loops, assuming you aren't strictly restricted to ANSI. The following uses PCRE.
(Note that this answer deliberately does not show the C code. It is only meant to guide the OP by showing a possible technique for using regexes, as it is not obvious how to do so.)
Method A
Uses two different regexes.
Part 1/2 (Demo)
Regex: ([^_\n]*)_([^_\n]*)(_.*)? Substitution: $2--$1$3
This moves the text following the next underscore to the beginning, appending -- to it. It also removes the underscore. You need to repeat this substitution in a loop until no more matches are found.
For your example, this leads to the following string:
this--something-like--bar--foo
Part 2/2 (Demo):
Regex: (.*)(?<!-)-(?!-)(\w+)(.*) Substitution: $1$3--$2
This moves the text following the next single hyphen to the end, prepending -- to it. It also removes the hyphen. You need to repeat this substitution in a loop until no more matches are found.
For your example, this leads to the following string:
this--something--bar--foo--like
Remove the hyphens from the string to get your result.
Note that the first regex can be simplified to the following and will still work:
([^_]*)_([^_]*)(_.*)?
The \ns were only required to show the intermediate loop results in the demos.
The following are the reasons for using -- as a new separator:
A separator is required so that the regex in part 2 can find the correct end of hyphen prefixed text;
A underscore can't be used as it would interfere with the regex in part 1 causing an infinite loop;
A hyphen can't be used as it would cause the regex in part 2 to find extraneous text;
Although any single character delimiter which can never exist in the input would work and lead to a simpler part 2 regexp, -- is one of the delimiters which allows any and every character* in the input.
\n is actually the perfect * delimiter, but can't be used in this answer as it would not allow the demo to show the intermediate results. (Hint: it should be the actual delimiter used by you.)
Method B
Combines the two regexes.
(Demo)
Regex: ([^_\n]*)_([^_\n]*)(_.*)?|(.*)(?<!-)-(?!-)(\w+)(.*) Substitution: $2--$1$3$4$6--$5
For your example, this leads to the following string:
----this------something--bar--foo----like
As before, remove all the hyphens from the string to get your result.
Also as before, the regex can be simplified to the following and will still work:
([^_]*)_([^_]*)(_.*)?|(.*)(?<!-)-(?!-)(\w+)(.*)
This combined regex works because capturing groups 1,2 & 3 are mutually exclusive to groups 4, 5 & 6. There is a side effect of extra hyphens, however.
Caveat:
* Using -- as a delimiter fails if the input contains consecutive hyphens. All the other "good" delimiters have a similar failure edge case. Only \n is guaranteed not to exist in the input and thus is failsafe.