mjhjmtu

Below is a the test question for a practice LPIC-1 exam I took. The correct answer is A. I'm really dazzled at how this is the case. If it's not too much trouble can someone walk me through how A is the correct answer?

int double(int n)
 /* int arg, int return */
 return n*2;
 
 char hello(int n)
 /* int arg, char return */
 printf("hello %in", n);
 
 int five()
 /* no args, int return */
 return 5;
 
 int triple(int n, int other, char nonsense)
 /* int arg, int return */
 return n*3;
 

Correctly parsing a C source file requires a full-fledged parser (such as that built into a C compiler). Nonetheless, regular expressions can be used to provide a pretty good approximate descriptions of many program constructs. Which of the following searches will locate at least most of the C functions that accept an int as a first argument, and return an int (and will not produce false positives very often). The exhibit contains a fragment of C code with several annotated matching and non-matching functions (for non-C programmers).

• A. grep -E "int[ t]+w+[ t]*([ t]*int" *.c
  


• B. grep -E "^intw+[A-Za-z_]+w*(w*int" *.c
  


• C. grep -E "int.+([ t]+int.*) " *.c
  


• D. grep -E "int[ t]+[A-Za-z_][ t]+(int" *.c
  

Reference: http://gnosis.cx/publish/programming/exam101.html - specifically this question - 1.3/7/1.

So "A." is the answer simply because it's the only one that returns the 2 functions defined in the sample code:

$ grep -E "int[ t]+w+[ t]*([ t]*int" sample.c
int double(int n)
 int triple(int n, int other, char nonsense)

The other 3 return nothing, if you were to try them. This one works because it's able to deal with both situations that present in these lines:

int double(int n)
 int triple(int n, int other, char nonsense)

The grep:

• 
  int[ t]+ - matches lines that begin with int followed by at least 1 space or tab (t)


• 
  w+ - this matches one or more characters in a word (double & triple)


• 
  [ t]* - zero or more spaces or tabs


• 
  ([ t]*int - a open paren (() followed by zero or more spaces or tabs followed by the string int
  

NOTE: the question assumes GNU grep since it's utilizing w. Other implementations of grep do not support this notation with their regex (-E), for these, using [[:alnum:]] is the better choice. Also a wiser choice would've been [[:blank:]] instead of [ t] since technically this matches spaces, backslashes, and t as POSIX requires.

Rewriting the "A." answer this is a much more compliant solution:

$ grep -E "int[[:blank:]]+[[:alpha:]_][[:alnum:]_]+[[:blank:]]*([[:blank:]]*int" sample.c

Here you can see in red what the above grep actually matched:

Assuming that when you take the test, you can't actually run the grep commands against the input data, then you will have to look at the expressions and do some guessing.

Looking at them in reverse order:

• 
  

  D. grep -E "int[ t]+[A-Za-z_][ t]+(int" *.c

  
  
  

  This does not allow for function names longer than a single character ([A-Za-z_]) and assumes that there must be at least a space, backslash or t between the function name and the argument list.

  
  
  

  Matches int a (int or int at(int but not int foo(int.

  
  


• 
  

  C. grep -E "int.+([ t]+int.*) " *.c

  
  
  

  This assumes that the argument list starts with at least one space, backslash or t.

  
  
  

  Matches int foo( int or int foo(tint but not int foo(int.

  
  


• 
  

  B. grep -E "^intw+[A-Za-z_]+w*(w*int" *.c

  
  
  

  This does not allow for any space between the int return type and the function name, and it assumes that the function definition starts at the start of the line (the example code contains some indented function definitions).

  
  
  

  Matches intfoo(int but not int foo(int.

  
  


• 
  

  A. grep -E "int[ t]+w+[ t]*([ t]*int" *.c

  
  
  

  This is the only one that allows a match on int foo(int, but it also matches invalid function names such as int 000(int. It is however the best regular expression out of the four given ones.

  
  

Note too that this question assumes GNU grep for matching w. With a standard grep implementation [[:alnum:]_] would have been better for w and [[:blank:]] should have been used in place of for matching space or tab ([ t] matches space, backslash or t).