#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <ctype.h>
#include <errno.h>
#include <sys/stat.h>
#include <sys/types.h>
#include "cobc.h"
#include "ppparse.h"

Include dependency graph for pplex.l:

Macros
#define	YY_READ_BUF_SIZE 32768

#define	YY_BUF_SIZE 32768

#define	YY_SKIP_YYWRAP

#define	ppwrap() 1

#define	PPLEX_BUFF_LEN 512

#define	YY_INPUT(buf, result, max_size) result = ppinput (buf, max_size);

#define	ECHO fputs (yytext, yyout)

#define	YY_USER_INIT

#define	COB_IN_PPLEX 1

#define	PLEX_COND_DEPTH 16

Functions
	yy_switch_to_buffer (buffer)

static int	ppinput (char *buff, const size_t max_size)

static struct cb_text_list *	pp_text_list_add (struct cb_text_list list, const char text, const size_t size)

static void	ppecho (const char *text, const cob_u32_t alt_space, const int textlen)

static void	skip_to_eol (void)

static void	display_to_eol (void)

static void	check_comments (const char keyword, const char text)

static void	check_listing (const char *text, const unsigned int comment)

Variables
option option case insensitive option never interactive option	prefix

Macro Definition Documentation

#define COB_IN_PPLEX 1

#define ECHO fputs (yytext, yyout)

#define PLEX_COND_DEPTH 16

#define PPLEX_BUFF_LEN 512

#define ppwrap ( ) 1

#define YY_BUF_SIZE 32768

#define YY_INPUT	(	buf,
		result,
		max_size
	)	result = ppinput (buf, max_size);

#define YY_READ_BUF_SIZE 32768

#define YY_SKIP_YYWRAP

#define YY_USER_INIT

Value:

if (!plexbuff1) {                       \
        plexbuff1 = cobc_malloc ((size_t)COB_SMALL_BUFF);   \
    }                               \
    if (!plexbuff2) {                       \
        plexbuff2 = cobc_malloc ((size_t)COB_SMALL_BUFF);   \
    }                               \
    requires_listing_line = 1;                  \
    comment_allowed = 1;

Function Documentation

static void check_comments	(	const char *	keyword,
		const char *	text
	)

static

References cb_verify(), comment_allowed, ppecho(), skip_to_eol(), within_comment, and yyleng.

 {
     /* Treated as comments when in Identification Division */
     if (comment_allowed) {
         cb_verify (cb_author_paragraph, keyword);
         /* Skip comments until the end of line */
         within_comment = 1;
         skip_to_eol ();
     } else {
         ppecho (text, 0, yyleng);
     }
 }

static void check_listing	(	const char *	text,
		const unsigned int	comment
	)

static

References CB_FORMAT_FIXED, cb_listing_file, cb_source_format, cobc_gen_listing, listing_line, requires_listing_line, requires_new_line, and cb_text_list::text.

Referenced by ppecho().

 {
     const char  *s;
     char        c;
 
     /* Check for listing */
     if (!cb_listing_file) {
         /* Nothing to do */
         return;
     }
     if (!text) {
         return;
     }
     if (cobc_gen_listing > 1) {
         /* Passed to cobxref */
         fputs (text, cb_listing_file);
         return;
     }
     if (comment) {
         c = '*';
     } else {
         c = ' ';
     }
 
     if (requires_listing_line) {
         if (requires_new_line) {
             requires_new_line = 0;
             putc ('\n', cb_listing_file);
         }
         fprintf (cb_listing_file, "%6d%c", ++listing_line, c);
     }
 
     if (requires_listing_line && cb_source_format == CB_FORMAT_FIXED &&
         strlen (text) > 6) {
         s = &text[6];
     } else {
         s = text;
     }
     fputs (s, cb_listing_file);
     if (strchr (text, '\n')) {
         requires_listing_line = 1;
     } else {
         requires_listing_line = 0;
     }
 }

static void display_to_eol ( void )

static

References input(), plex_skip_input, and unput.

 {
     int c;
 
     while ((c = input ()) != EOF) {
         if (c == '\n') {
             break;
         }
         if (!plex_skip_input) {
             putchar (c);
         }
     }
     if (!plex_skip_input) {
         putchar ('\n');
     }
     if (c != EOF) {
         unput (c);
     }
 }

static struct cb_text_list* pp_text_list_add	(	struct cb_text_list *	list,
		const char *	text,
		const size_t	size
	)

staticread

References cobc_plex_malloc(), cb_text_list::last, cb_text_list::next, p, and cb_text_list::text.

Referenced by ppecho().

 {
     struct cb_text_list *p;
     void            *tp;
 
     p = cobc_plex_malloc (sizeof (struct cb_text_list));
     tp = cobc_plex_malloc (size + 1);
     memcpy (tp, text, size);
     p->text = tp;
     if (!list) {
         p->last = p;
         return p;
     }
     list->last->next = p;
     list->last = p;
     return list;
 }

static void ppecho	(	const char *	text,
		const cob_u32_t	alt_space,
		const int	textlen
	)

static

References base_replace_list, cb_listing_file, CB_REPLACE_LEADING, CB_REPLACE_TRAILING, check_listing(), cobc_free(), cobc_strdup(), current_replace_list, cb_replace_list::last, cb_replace_list::lead_trail, cb_replace_list::new_text, cb_text_list::next, cb_replace_list::next, NULL, cb_replace_list::old_text, pp_text_list_add(), ppout, cb_text_list::text, text_queue, and yytext.

Referenced by check_comments().

 {
     struct cb_replace_list      *r;
     struct cb_replace_list      *save_ptr;
     const struct cb_text_list   *lno;
     struct cb_text_list     *queue;
     struct cb_text_list     *save_queue;
     const char          *s;
     char                *temp_ptr;
     size_t              size;
     size_t              size2;
 
     /* Check for replacement text before outputting */
     if (alt_space) {
         s = yytext;
     } else {
         s = text;
     }
 
     if (text_queue == NULL && (text[0] == ' ' || text[0] == '\n')) {
         /* No replacement */
         fwrite (text, (size_t)textlen, (size_t)1, ppout);
         if (cb_listing_file) {
             check_listing (s, 0);
         }
         return;
     }
     if (!current_replace_list && !base_replace_list) {
         /* Ouput queue */
         for (; text_queue; text_queue = text_queue->next) {
             fputs (text_queue->text, ppout);
         }
         fwrite (text, (size_t)textlen, (size_t)1, ppout);
         if (cb_listing_file) {
             check_listing (s, 0);
         }
         return;
     }
     if (!current_replace_list) {
         current_replace_list = base_replace_list;
         save_ptr = NULL;
     } else {
         current_replace_list->last->next = base_replace_list;
         save_ptr = current_replace_list->last;
     }
 
     /* Do replacement */
     text_queue = pp_text_list_add (text_queue, text, (size_t)textlen);
 
     save_queue = NULL;
     size = 0;
     size2 = 0;
     for (r = current_replace_list; r; r = r->next) {
         queue = text_queue;
         /* The LEADING/TRAILING code looks peculiar as we use */
         /* variables after breaking out of the loop BUT */
         /* ppparse.y guarantees that we have only one token */
         /* and therefore only one iteration of this loop */
         for (lno = r->old_text; lno; lno = lno->next) {
             if (lno->text[0] == ' ' || lno->text[0] == '\n') {
                 continue;
             }
             while (queue && (queue->text[0] == ' ' ||
                    queue->text[0] == '\n')) {
                 queue = queue->next;
             }
             if (queue == NULL) {
                 /* Partial match */
                 if (!save_ptr) {
                     current_replace_list = NULL;
                 } else {
                     save_ptr->next = NULL;
                 }
                 return;
             }
             if (r->lead_trail == CB_REPLACE_LEADING) {
                 /* Check leading text */
                 size = strlen (lno->text);
                 if (strncasecmp (lno->text, queue->text, size)) {
                     /* No match */
                     break;
                 }
                 save_queue = queue;
             } else if (r->lead_trail == CB_REPLACE_TRAILING) {
                 /* Check trailing text */
                 size = strlen (lno->text);
                 size2 = strlen (queue->text);
                 if (size2 < size) {
                     /* No match */
                     break;
                 }
                 size2 -= size;
                 if (strncasecmp (lno->text, queue->text + size2, size)) {
                     /* No match */
                     break;
                 }
                 save_queue = queue;
             } else if (strcasecmp (lno->text, queue->text)) {
                 /* No match */
                 break;
             }
             queue = queue->next;
         }
         if (lno == NULL) {
             /* Match */
             if (r->lead_trail == CB_REPLACE_TRAILING) {
                 /* Non-matched part of original text */
                 fprintf (ppout, "%*.*s", (int)size2, (int)size2,
                      save_queue->text);
                 if (cb_listing_file) {
                     temp_ptr = cobc_strdup (save_queue->text);
                     *(temp_ptr + size2) = 0;
                     check_listing (temp_ptr, 0);
                     cobc_free (temp_ptr);
                 }
             }
             for (lno = r->new_text; lno; lno = lno->next) {
                 fputs (lno->text, ppout);
                 if (cb_listing_file) {
                     check_listing (lno->text, 0);
                 }
             }
             if (r->lead_trail == CB_REPLACE_LEADING) {
                 /* Non-matched part of original text */
                 fputs (save_queue->text + size, ppout);
                 if (cb_listing_file) {
                     check_listing (save_queue->text + size, 0);
                 }
             }
             text_queue = queue;
             continue;
         }
     }
 
     /* No match */
     for (; text_queue; text_queue = text_queue->next) {
         fputs (text_queue->text, ppout);
         if (cb_listing_file) {
             check_listing (text_queue->text, 0);
         }
     }
     if (!save_ptr) {
         current_replace_list = NULL;
     } else {
         save_ptr->next = NULL;
     }
 }

static int ppinput	(	char *	buff,
		const size_t	max_size
	)

static

References _, buffer_overflow, CB_FORMAT_FIXED, CB_FORMAT_FREE, cb_plex_error(), cb_plex_warning(), cb_source_format, consecutive_quotation, likely, need_continuation, newline_count, plex_skip_input, ppin, PPLEX_BUFF_LEN, quotation_mark, unlikely, within_comment, and YY_NULL.

 {
     char    *bp;
     size_t  gotcr;
     size_t  line_overflow;
     size_t  continuation;
     int ipchar;
     int i;
     int n;
     int coln;
 
     /* Read line(s) */
 
     continuation = 0;
 start:
     if (unlikely(buffer_overflow ||
              (newline_count + PPLEX_BUFF_LEN) >= max_size)) {
         if (need_continuation || continuation) {
             cb_plex_error (newline_count,
                     _("Buffer overrun - Too much continuation lines"));
             return YY_NULL;
         }
         if (newline_count < max_size) {
             memset (buff, '\n', newline_count);
             buff[newline_count] = 0;
             ipchar = (int)newline_count;
             newline_count = 0;
             buffer_overflow = 0;
             return ipchar;
         }
         buffer_overflow = 1;
         ipchar = max_size - 1;
         memset (buff, '\n', (size_t)ipchar);
         buff[ipchar] = 0;
         newline_count -= ipchar;
         return ipchar;
     }
     gotcr = 0;
     line_overflow = 0;
     ipchar = 0;
     for (n = 0; ipchar != '\n';) {
         if (unlikely(n == PPLEX_BUFF_LEN)) {
             if (line_overflow != 2) {
                 line_overflow = 1;
             }
         }
         ipchar = getc (ppin);
         if (unlikely(ipchar == EOF)) {
             if (n > 0) {
                 /* No end of line at end of file */
                 break;
             }
             if (newline_count == 0) {
                 return YY_NULL;
             }
             memset (buff, '\n', newline_count);
             buff[newline_count] = 0;
             ipchar = (int)newline_count;
             newline_count = 0;
             return ipchar;
         }
 #ifndef COB_EBCDIC_MACHINE
         if (unlikely(ipchar == 0x1A && !n)) {
             continue;
         }
 #endif
         if (unlikely(gotcr)) {
             gotcr = 0;
             if (ipchar != '\n') {
                 if (likely(line_overflow == 0)) {
                     buff[n++] = '\r';
                 } else {
                     line_overflow = 2;
                 }
             }
         }
         if (unlikely(ipchar == '\r')) {
             gotcr = 1;
             continue;
         }
         if (unlikely(ipchar == '\t')) {
             if (likely(line_overflow == 0)) {
                 buff[n++] = ' ';
                 while (n % cb_tab_width != 0) {
                     buff[n++] = ' ';
                 }
                 if (unlikely(n > PPLEX_BUFF_LEN)) {
                     n = PPLEX_BUFF_LEN;
                 }
             }
             continue;
         }
         if (likely(line_overflow == 0)) {
             buff[n++] = (char)ipchar;
         } else if ((char)ipchar != ' ' && (char)ipchar != '\n') {
             line_overflow = 2;
         }
     }
 
     if (buff[n - 1] != '\n') {
         /* FIXME: cb_source_line is one too low when CB_FORMAT_FREE is used
            [but only during ppinput() in pplex.l ?] - Workaround for now:
            Temporary newline_count + 1
         */
         if (cb_source_format == CB_FORMAT_FREE) {
             if (line_overflow == 0) {
                 cb_plex_warning (newline_count + 1,
                          _("Line not terminated by a newline"));
             } else if (line_overflow == 2) {
                 cb_plex_warning (newline_count + 1,
                          _("Source text exceeds %d bytes, will be truncated"), PPLEX_BUFF_LEN);
             }
         } else {
             if (line_overflow == 0) {
                 cb_plex_warning (newline_count,
                          _("Line not terminated by a newline"));
             } else if (line_overflow == 2) {
                 cb_plex_warning (newline_count,
                          _("Source text exceeds %d bytes, will be truncated"), PPLEX_BUFF_LEN);
             }
         }
         buff[n++] = '\n';
     }
     buff[n] = 0;
 
     if (cb_source_format == CB_FORMAT_FIXED) {
         if (n < 8) {
             /* Line too short */
             newline_count++;
             goto start;
         }
 
         if (cb_flag_mfcomment) {
             if (buff[0] == '*' || buff[0] == '/') {
                 newline_count++;
                 goto start;
             }
         }
 
         /* Check if text is longer than cb_text_column */
         if (n > cb_text_column + 1) {
             /* Show warning if it is not whitespace
                (postponed after checking for comments by setting
                 line_overflow to first column that leads to
                 "source text too long")
             */
             if (cb_warn_column_overflow && line_overflow == 0) {
                 for (coln = cb_text_column; coln < n; ++coln) {
                     if (buff[coln] != ' ' && buff[coln] != '\n') {
                         line_overflow = coln;
                         break;
                     }
                 }
             } else {
                 line_overflow = 0;
             }
             /* Remove it */
             buff[cb_text_column] = '\n';
             buff[cb_text_column + 1] = 0;
             n = cb_text_column + 1;
         } else {
             line_overflow = 0;
         }
 
         memset (buff, ' ', (size_t)6);
         /* Note we allow directive lines to start at column 7 */
         bp = &buff[6];
     } else {
         bp = buff;
     }
 
     /* Check for directives/floating comment at first non-space of line */
     ipchar = 0;
     i = 0;
     for (; *bp; bp++) {
         if (*bp != ' ') {
             if ((*bp == '$' && !(cb_source_format == CB_FORMAT_FIXED && i == 0)) ||
                 (*bp == '>' && bp[1] == '>'                                    )   ) {
                 /* Directive */
                 ipchar = 1;
             } else if ((*bp == '*' && bp[1] == '>'      ) ||
                        (cb_flag_acucomment && *bp == '|')   ) {
                 /* Float comment */
                 newline_count++;
                 goto start;
             }
             break;
         }
         i = 1;
     }
     if (ipchar) {
         /* Directive - pass complete line with NL to ppparse */
         if (newline_count) {
             /* Move including NL and NULL byte */
             memmove (buff + newline_count, buff, (size_t)(n + 1));
             memset (buff, '\n', newline_count);
             n += newline_count;
             newline_count = 0;
         }
         return n;
     }
 
     if (plex_skip_input) {
         /* Skipping input */
         newline_count++;
         goto start;
     }
 
     /* Return when free format (no floating comments removed!) */
     if (cb_source_format == CB_FORMAT_FREE) {
         within_comment = 0;
         if (newline_count) {
             memmove (buff + newline_count, buff, (size_t)(n + 1));
             memset (buff, '\n', newline_count);
             n += newline_count;
             newline_count = 0;
         }
         return n;
     }
 
     /* Fixed format */
 
     /* Check the indicator (column 7) */
     if (cb_flag_acucomment && buff[6] == '$') {
         buff[6] = '*';
     }
     switch (buff[6]) {
     case ' ':
         break;
     case '-':
         if (unlikely(within_comment)) {
             cb_plex_error (newline_count,
                     _("Invalid continuation in comment entry"));
             newline_count++;
             goto start;
         }
         continuation = 1;
         break;
     case 'd':
     case 'D':
         /* Debugging line */
         if (cb_flag_debugging_line) {
             break;
         }
         newline_count++;
         goto start;
     case '*':
     case '/':
         /* Comment line */
         newline_count++;
         goto start;
     default:
         /* Invalid indicator */
         cb_plex_error (newline_count,
                 _("Invalid indicator '%c' at column 7"), buff[6]);
         newline_count++;
         return YY_NULL;
     }
 
     /* Skip comments that follow after AUTHORS, etc. */
     if (unlikely(within_comment)) {
         /* Check all of "Area A" */
         for (ipchar = 7; ipchar < (n - 1) && ipchar < 11; ++ipchar) {
             if (buff[ipchar] != ' ') {
                 ipchar = 0;
                 break;
             }
         }
         if (ipchar) {
             newline_count++;
             goto start;
         }
         within_comment = 0;
     }
 
     /* Skip blank lines */
     for (i = 7; buff[i] == ' '; ++i) {
         ;
     }
 
     if (buff[i] == '\n') {
         newline_count++;
         goto start;
     }
 
     buff[6] = ' ';
     bp = buff + 7;
 
     if (unlikely(continuation)) {
         /* Line continuation */
         need_continuation = 0;
         for (; *bp == ' '; ++bp) {
             ;
         }
         /* Validate concatenation */
         if (consecutive_quotation) {
             if (bp[0] == quotation_mark && bp[1] == quotation_mark) {
                 bp++;
             } else {
                 cb_plex_error (newline_count,
                         _("Invalid line continuation"));
                 return YY_NULL;
             }
             quotation_mark = 0;
             consecutive_quotation = 0;
         } else if (quotation_mark) {
             /* Literal concatenation */
             if (*bp == quotation_mark) {
                 bp++;
             } else {
                 cb_plex_error (newline_count,
                         _("Invalid line continuation"));
                 return YY_NULL;
             }
         }
     } else {
         /* Normal line */
         if (need_continuation) {
             cb_plex_error (newline_count,
                     _("Continuation character expected"));
             need_continuation = 0;
         }
         quotation_mark = 0;
         consecutive_quotation = 0;
     }
 
     /* Check if string literal is to be continued */
     for (i = bp - buff; buff[i] != '\n'; ++i) {
         /* Pick up floating comment and force loop exit */
         if (!quotation_mark && ((buff[i] == '*' && buff[i + 1] == '>') ||
                                 (cb_flag_acucomment && buff[i] == '|') ) ) {
             /* remove indicator "source text too long" if the column
                leading to the indicator comes after the floating comment
             */
             if (i < cb_text_column) {
                 line_overflow = 0;
             }
             /* Set to null, 'i' is predecremented further below */
             buff[i] = 0;
             break;
         } else if (buff[i] == '\'' || buff[i] == '"') {
             if (quotation_mark == 0) {
                 /* Literal start */
                 quotation_mark = buff[i];
             } else if (quotation_mark == buff[i]) {
                 if (i == cb_text_column - 1) {
                     /* Consecutive quotation */
                     consecutive_quotation = 1;
                 } else {
                     /* Literal end */
                     quotation_mark = 0;
                 }
             }
         }
     }
 
     if (unlikely(quotation_mark)) {
         /* Expecting continuation */
         if (!consecutive_quotation) {
             need_continuation = 1;
         }
         for (; i < cb_text_column;) {
             buff[i++] = ' ';
         }
         buff[i] = 0;
     } else {
         /* Truncate trailing spaces, including the newline */
         for (i--; i >= 0 && buff[i] == ' '; i--) {
             ;
         }
         if (i < 0) {
             /* Empty line after removing floating comment */
             newline_count++;
             goto start;
         }
         if (buff[i] == '\'' || buff[i] == '\"') {
             buff[++i] = ' ';
         }
         buff[i + 1] = 0;
     }
 
     /* Show warning if text is longer than cb_text_column
        and not whitespace (postponed here) */
     if (line_overflow != 0) {
         cb_plex_warning (newline_count,
                     _("Source text after column %d"),
                 cb_text_column);
     }
 
     if (unlikely(continuation)) {
         gotcr = strlen (bp);
         memmove (buff, bp, gotcr + 1);
         newline_count++;
     } else {
         /* Insert newlines at the start of the buffer */
         gotcr = strlen (buff);
         if (newline_count != 0) {
             memmove (buff + newline_count, buff, gotcr + 1);
             memset (buff, '\n', newline_count);
             gotcr += newline_count;
         }
         newline_count = 1;
     }
     return (int)gotcr;
 }

static void skip_to_eol ( void )

static

References input(), and unput.

Referenced by check_comments().

 {
     int c;
 
     /* Skip bytes to end of line */
     while ((c = input ()) != EOF) {
         if (c == '\n') {
             break;
         }
     }
     if (c != EOF) {
         unput (c);
     }
 }

yy_switch_to_buffer ( buffer )

Variable Documentation

option option case insensitive option never interactive option prefix

Referenced by cob_chk_file_env().

Macros

Functions

Variables

Macro Definition Documentation

Function Documentation

Variable Documentation