Detecting mismatches against constants in scanf format string - c

Question

From the man page of scanf:
A directive is one of the following:
A sequence of white-space characters (space, tab, newline, etc.; see isspace(3)). This directive matches any amount of
white space, including none, in the input.
An ordinary character (i.e., one other than white space or '%'). This character must exactly match the next character of
input. (emphasis mine)
A conversion specification, which commences with a '%' (percent) character. A sequence of characters from the input is
converted according to this specification, and the result is placed in
the corresponding pointer
argument. If the next item of input does not match the conversion specification, the conversion fails—this is a matching
failure.
Now, consider the following code:
#include <stdio.h>
int main(void)
{
const char* fmt = "A %49s B";
char buf[50];
printf("%d\n", sscanf("A foo B", fmt, buf)); // 1
printf("%d\n", sscanf("blah blaaah blah", fmt, buf)); // 0
printf("%d\n", sscanf("A blah blah", fmt, buf)); // 1
return 0;
}
Lines 1 and 3 print 1 because matching "A" with "A" succeeds, as does matching "foo"/"blah" with %s. Line 2 prints 0 because "A" cannot be matched with "blah", so parsing stops there.
This is all fine and logical, but is there any way for me to detect that a matching failure occurred after all conversion specifications have been successfully matched and assigned? In that case, the value returned by scanf will be the number of conversion specifiers in my format string, so I can't use it to tell if matching succeeded till the very end.
In other words: the string fed to sscanf in line 3 is not "valid" in the sense that it's not in the format A [something] B. Can I use scanf to detect this, or is strtok my only option?

Answer 1

Employ a " %n" at the end of the format.
Directives:
" " scans 0 or more white-space. It does not fail.
"%n" saves the count of the number of characters parsed so far (as an int). It does not fail.
Set n to 0 and test to see that it changed. The change would only happen if the entire preceding format succeeded. Also test that the scan ended on a null character - thus detecting trail unwanted text.
The added " ", though optional, if very useful as typically a trailing white-space, which is often a '\n', is not offensive. It negates the needed for a scanned line of text to be preprocessed to have its line ending removed.
#include <stdio.h>
void test(const char *s) {
const char* fmt = "A %49s B %n";
char buf[50];
int n = 0;
int cnt = sscanf(s, fmt, buf, &n);
int success = n > 0 && s[n] == '\0';
printf("sscanf():%2d n:%2d success:%d '%s'\n", cnt, n, success, s);
}
int main(void) {
test("A foo B");
test("blah blaaah blah");
test("A blah blah");
test("A foo B ");
test("A foo B x");
test("");
return 0;
}
Output
sscanf(): 1 n: 7 success:1 'A foo B'
sscanf(): 0 n: 0 success:0 'blah blaaah blah'
sscanf(): 1 n: 0 success:0 'A blah blah'
sscanf(): 1 n: 8 success:1 'A foo B '
sscanf(): 1 n: 8 success:0 'A foo B x'
sscanf():-1 n: 0 success:0 ''
Note that success is determined by n alone. On lack of success, the destination scanned variables like buf should not be used. If a partial result is needed, then use the return value of sscanf().

Answer 2

If you want to parse more complex input, use a proper parser/lexxer. Otherwise, have a look at the %n conversion specifier:
No input is consumed. The corresponding argument shall be a pointer to signed integer into which is to be written the number of characters read from the input stream so far by this call to the fscanf function. Execution of a %n directive does not increment the assignment count returned at the completion of execution of the fscanf function. No argument is converted, but one is consumed. If the conversion specification includes an assignment- suppressing character or a field width, the behavior is undefined.
You can use this multiple times: after the last variable conversion and one at the end.

Answer 3

For OP's use case, regex can equally be used to match the pattern.
/* see http://linux.die.net/man/3/regex */
#include <stdio.h>
#include <stdlib.h>
#include <regex.h>
int regexp(const char *);
int main(int argc, char **argv){
printf("%d\n", regexp("A foo B"));
printf("%d\n", regexp("blah blaaah blah"));
printf("%d\n", regexp("A blah blah"));
return EXIT_SUCCESS;
}
int regexp(const char *input_str){
char buf[100];
regex_t regex;
int rcval;
/* compile regexp - see http://linux.die.net/man/3/regcomp */
rcval = regcomp(&regex, "^A\\s.*\\sB$", 0);
if (rcval) {
fprintf(stderr, "Could not compile regex\n");
return -1;
}
/* execute regexp - see http://linux.die.net/man/3/regexec */
rcval = regexec(&regex, input_str, 0, NULL, 0);
if (!rcval) {
fprintf(stdout, "Match\n");
regfree(&regex);
return 1;
}else{
if (rcval == REG_NOMATCH) {
fprintf(stdout, "No match\n");
regfree(&regex);
return 0;
}else{
regerror(rcval, &regex, msgbuf, sizeof(msgbuf));
fprintf(stderr, "Regex match failed: %s\n", msgbuf);
regfree(&regex);
return -1;
}
}
return 0; // default to no match
}

Answer 4

If you are only interested in whether the entire format has been scanned, but do not care about trailing text in the stream, you can use this terse method:
int success = 0;
fscanf(stream, "A %49s B%n", buf, &success);
if(!success) handleError();
The trick is, that the "%n" conversion does not happen unless the entire format is matched successfully. Since any matching of the format will consume one or more characters from the stream, the value that the "%n" writes will always be non-zero. Thus, success will be set to a truthy value if, and only if the entire format was matched.