if (compatMake && (lastc != '\\')) {
if ( #if 0 compatMake && #endif (lastc != '\\')) {
ParseReadLine (){    Buffer  	  buf;	    	/* Buffer for current line */    register int  c;	      	/* the current character */    register int  lastc;    	/* The most-recent character */    Boolean	  semiNL;     	/* treat semi-colons as newlines */    Boolean	  ignDepOp;   	/* TRUE if should ignore dependency operators				 * for the purposes of setting semiNL */    Boolean 	  ignComment;	/* TRUE if should ignore comments (in a				 * shell command */    char 	  *line;    	/* Result */    char          *ep;		/* to strip trailing blanks */    int	    	  lineLength;	/* Length of result */    semiNL = FALSE;    ignDepOp = FALSE;    ignComment = FALSE;    /*     * Handle special-characters at the beginning of the line. Either a     * leading tab (shell command) or pound-sign (possible conditional)     * forces us to ignore comments and dependency operators and treat     * semi-colons as semi-colons (by leaving semiNL FALSE). This also     * discards completely blank lines.     */    for (;;) {	c = ParseReadc();	if (c == '\t') {	    ignComment = ignDepOp = TRUE;	    break;	} else if (c == '\n') {	    lineno++;	} else if (c == '#') {	    ParseUnreadc(c);	    break;	} else {	    /*	     * Anything else breaks out without doing anything	     */	    break;	}    }	    if (c != EOF) {	lastc = c;	buf = Buf_Init(MAKE_BSIZE);		while (((c = ParseReadc ()) != '\n' || (lastc == '\\')) &&	       (c != EOF))	{test_char:	    switch(c) {	    case '\n':		/*		 * Escaped newline: read characters until a non-space or an		 * unescaped newline and replace them all by a single space.		 * This is done by storing the space over the backslash and		 * dropping through with the next nonspace. If it is a		 * semi-colon and semiNL is TRUE, it will be recognized as a		 * newline in the code below this...		 */		lineno++;		lastc = ' ';		while ((c = ParseReadc ()) == ' ' || c == '\t') {		    continue;		}		if (c == EOF || c == '\n') {		    goto line_read;		} else {		    /*		     * Check for comments, semiNL's, etc. -- easier than		     * ParseUnreadc(c); continue;		     */		    goto test_char;		}		/*NOTREACHED*/		break;	    case ';':		/*		 * Semi-colon: Need to see if it should be interpreted as a		 * newline		 */		if (semiNL) {		    /*		     * To make sure the command that may be following this		     * semi-colon begins with a tab, we push one back into the		     * input stream. This will overwrite the semi-colon in the		     * buffer. If there is no command following, this does no		     * harm, since the newline remains in the buffer and the		     * whole line is ignored.		     */		    ParseUnreadc('\t');		    goto line_read;		} 		break;	    case '=':		if (!semiNL) {		    /*		     * Haven't seen a dependency operator before this, so this		     * must be a variable assignment -- don't pay attention to		     * dependency operators after this.		     */		    ignDepOp = TRUE;		} else if (lastc == ':' || lastc == '!') {		    /*		     * Well, we've seen a dependency operator already, but it		     * was the previous character, so this is really just an		     * expanded variable assignment. Revert semi-colons to		     * being just semi-colons again and ignore any more		     * dependency operators.		     *		     * XXX: Note that a line like "foo : a:=b" will blow up,		     * but who'd write a line like that anyway?		     */		    ignDepOp = TRUE; semiNL = FALSE;		}		break;	    case '#':		if (!ignComment) {		    if (compatMake && (lastc != '\\')) {			/*			 * If the character is a hash mark and it isn't escaped			 * (or we're being compatible), the thing is a comment.			 * Skip to the end of the line.			 */			do {			    c = ParseReadc();			} while ((c != '\n') && (c != EOF));			goto line_read;		    } else {			/*			 * Don't add the backslash. Just let the # get copied			 * over.			 */			lastc = c;			continue;		    }		}		break;	    case ':':	    case '!':		if (!ignDepOp && (c == ':' || c == '!')) {		    /*		     * A semi-colon is recognized as a newline only on		     * dependency lines. Dependency lines are lines with a		     * colon or an exclamation point. Ergo...		     */		    semiNL = TRUE;		}		break;	    }	    /*	     * Copy in the previous character and save this one in lastc.	     */	    Buf_AddByte (buf, (Byte)lastc);	    lastc = c;	    	}    line_read:	lineno++;		if (lastc != '\0') {	    Buf_AddByte (buf, (Byte)lastc);	}	Buf_AddByte (buf, (Byte)'\0');	line = (char *)Buf_GetAll (buf, &lineLength);	Buf_Destroy (buf, FALSE);	/*	 * Strip trailing blanks and tabs from the line.	 * Do not strip a blank or tab that is preceeded by	 * a '\'	 */	ep = line;	while (*ep)	    ++ep;	while (ep > line && (ep[-1] == ' ' || ep[-1] == '\t')) {	    if (ep > line + 1 && ep[-2] == '\\')		break;	    --ep;	}	*ep = 0;		if (line[0] == '.') {	    /*	     * The line might be a conditional. Ask the conditional module	     * about it and act accordingly	     */	    switch (Cond_Eval (line)) {	    case COND_SKIP:		/*		 * Skip to next conditional that evaluates to COND_PARSE.		 */		do {		    free (line);		    line = ParseSkipLine(1);		} while (line && Cond_Eval(line) != COND_PARSE);		if (line == NULL)		    break;		/*FALLTHRU*/	    case COND_PARSE:		free ((Address) line);		line = ParseReadLine();		break;	    case COND_INVALID:		if (For_Eval(line)) {		    int ok;		    free(line);		    do {			/*			 * Skip after the matching end			 */			line = ParseSkipLine(0);			if (line == NULL) {			    Parse_Error (PARSE_FATAL, 				     "Unexpected end of file in for loop.\n");			    break;			}			ok = For_Eval(line);			free(line);		    }		    while (ok);		    if (line != NULL)			For_Run();		    line = ParseReadLine();		}		break;	    }	}	return (line);    } else {	/*	 * Hit end-of-file, so return a NULL line to indicate this.	 */	return((char *)NULL);    }}