WebSVN – tendra.SVN – Diff – /branches/tendra5/src/tools/tnc/analyser.c

+/*
+ * Copyright (c) 2002-2005 The TenDRA Project <http://www.tendra.org/>.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. Neither the name of The TenDRA Project nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific, prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
+ * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $Id$
+ */
 /*
     		 Crown Copyright (c) 1997
     This TenDRA(r) Computer Program is subject to Copyright
     owned by the United Kingdom Secretary of State for Defence
     acting through the Defence Evaluation and Research Agency
     (DERA).  It is made available to Recipients with a
     royalty-free licence for its use, reproduction, transfer
     to other parties and amendment for any purpose not excluding
     product development provided that any such use et cetera
     shall be deemed to be acceptance of the following conditions:-
         (1) Its Recipients shall ensure that this Notice is
         reproduced upon any copies or amended versions of it;
         (2) Any amended version of it shall be clearly marked to
         show both the nature of and the organisation responsible
         for the relevant amendment or amendments;
         (3) Its onward transfer from a recipient to another
         party shall be deemed to be that party's acceptance of
         these conditions;
         (4) DERA gives no warranty or assurance as to its
         quality or suitability for any purpose and DERA accepts
         no liability whatsoever in relation to any use to which
         it may be put.
 */
     The current line in the file is recorded.  The previous line (where
     any errors were likely to have been) is also saved.
 */
-long crt_line_no = 1 ;
+long crt_line_no = 1;
-long line_no = 1 ;
+long line_no = 1;
 /*
     FORM OF INPUT
     This flag controls whether the input should be lisp-like (default)
     or c-like.
 */
-boolean func_input = 0 ;
+boolean func_input = 0;
 /*
     ANALYSE FLAGS
     The looked_ahead flag is true to indicate that the next word has
     already been read.  The really_analyse flag is false to indicate
     that the next word may be ignored.
 */
-boolean looked_ahead = 0 ;
+boolean looked_ahead = 0;
-static boolean really_analyse = 1 ;
+static boolean really_analyse = 1;
 /*
     INPUT BUFFER
     The input is read into a buffer.
 */
 #define BUFFSIZE	5000
-static char word_buff [ BUFFSIZE ] ;
+static char word_buff[BUFFSIZE];
 /*
     LAST WORD READ
     The word just read from the input file is word.  It has length
     word_length and input type word_type.
 */
-char *word = "" ;
+char *word = "";
-long word_length ;
+long word_length;
-int word_type = INPUT_EOF ;
+int word_type = INPUT_EOF;
 /*
     PENDING CHARACTER
     In reading a word we almost always read one too many character.
     This is stored in pending.  A value of 0 indicates that there is
     no pending character.
 */
-static int pending = 0 ;
+static int pending = 0;
 /*
     READ THE NEXT WORD
     The next word is read from the input file.
 */
-void read_word
+void
-    PROTO_Z ()
+read_word(void)
+{
-    int c ;
+    int c;
-    char *p ;
+    char *p;
-    int negate = 0 ;
+    int negate = 0;
-    unsigned base = 10 ;
+    unsigned base = 10;
     /* If we have looked ahead one, return last value */
-    if ( looked_ahead ) {
+    if (looked_ahead) {
-	looked_ahead = 0 ;
+	looked_ahead = 0;
-	return ;
+	return;
+    }
     /* Get the first letter */
-    if ( pending ) {
+    if (pending) {
-	c = pending ;
+	c = pending;
-	if ( c == EOF ) {
+	if (c == EOF) {
-	    word_type = INPUT_EOF ;
+	    word_type = INPUT_EOF;
-	    return ;
+	    return;
+	}
-	pending = 0 ;
+	pending = 0;
     } else {
-	c = getc ( input ) ;
+	c = getc(input);
-	if ( c == '\n' ) crt_line_no++ ;
+	if (c == '\n')crt_line_no++;
+    }
     /* Step over any white space and comments */
-    while ( white_space ( c ) || c == '#' ) {
+    while (white_space(c) || c == '#') {
-	if ( c == '#' ) {
+	if (c == '#') {
 	    /* Comments go to the end of the line */
-	    while ( c = getc ( input ), c != '\n' ) {
+	    while (c = getc(input), c != '\n') {
-		if ( c == EOF ) {
+		if (c == EOF) {
-		    is_fatal = 0 ;
+		    is_fatal = 0;
-		    input_error ( "End of file in comment" ) ;
+		    input_error("End of file in comment");
-		    word_type = INPUT_EOF ;
+		    word_type = INPUT_EOF;
-		    pending = EOF ;
+		    pending = EOF;
-		    return ;
+		    return;
+		}
+	    }
-	    crt_line_no++ ;
+	    crt_line_no++;
 	} else {
-	    c = getc ( input ) ;
+	    c = getc(input);
-	    if ( c == '\n' ) crt_line_no++ ;
+	    if (c == '\n')crt_line_no++;
+	}
+    }
-    line_no = crt_line_no ;
+    line_no = crt_line_no;
     /* Check for end of file */
-    if ( c == EOF ) {
+    if (c == EOF) {
-	word_type = INPUT_EOF ;
+	word_type = INPUT_EOF;
-	pending = EOF ;
+	pending = EOF;
-	return ;
+	return;
+    }
     /* Check for open brackets */
-    if ( c == '(' ) {
+    if (c == '(') {
-	word = "(" ;
+	word = "(";
-	word_type = INPUT_OPEN ;
+	word_type = INPUT_OPEN;
-	return ;
+	return;
+    }
     /* Check for close brackets */
-    if ( c == ')' ) {
+    if (c == ')') {
-	word = ")" ;
+	word = ")";
-	word_type = INPUT_CLOSE ;
+	word_type = INPUT_CLOSE;
-	return ;
+	return;
+    }
-    if ( func_input ) {
+    if (func_input) {
 	/* Check for commas (c-like input only) */
-	if ( c == ',' ) {
+	if (c == ',') {
-	    word = "," ;
+	    word = ",";
-	    word_type = INPUT_COMMA ;
+	    word_type = INPUT_COMMA;
-	    return ;
+	    return;
+	}
 	/* Check for semicolons (c-like input only) */
-	if ( c == ';' ) {
+	if (c == ';') {
-	    word = ";" ;
+	    word = ";";
-	    word_type = INPUT_SEMICOLON ;
+	    word_type = INPUT_SEMICOLON;
-	    return ;
+	    return;
+	}
+    }
     /* Check for strings */
-    if ( c == '"' ) {
+    if (c == '"') {
-	boolean escaped ;
+	boolean escaped;
-	p = word_buff ;
+	p = word_buff;
 	do {
-	    boolean ignore = 0 ;
+	    boolean ignore = 0;
-	    escaped = 0 ;
+	    escaped = 0;
-	    c = getc ( input ) ;
+	    c = getc(input);
-	    if ( c == '\n' ) {
+	    if (c == '\n') {
-		is_fatal = 0 ;
+		is_fatal = 0;
-		input_error ( "New line in string" ) ;
+		input_error("New line in string");
-		crt_line_no++ ;
+		crt_line_no++;
-		line_no = crt_line_no ;
+		line_no = crt_line_no;
-		ignore = 1 ;
+		ignore = 1;
+	    }
-	    if ( c == '\\' ) {
+	    if (c == '\\') {
-		escaped = 1 ;
+		escaped = 1;
-		c = getc ( input ) ;
+		c = getc(input);
-		if ( c == '\n' ) {
+		if (c == '\n') {
-		    crt_line_no++ ;
+		    crt_line_no++;
-		    line_no = crt_line_no ;
+		    line_no = crt_line_no;
-		    ignore = 1 ;
+		    ignore = 1;
-		} else if ( c == 'n' ) {
+		} else if (c == 'n') {
-		    c = '\n' ;
+		    c = '\n';
-		} else if ( c == 't' ) {
+		} else if (c == 't') {
-		    c = '\t' ;
+		    c = '\t';
-		} else if ( octal_digit ( c ) ) {
+		} else if (octal_digit(c)) {
-		    int e = ( c - '0' ) ;
+		    int e = (c - '0');
-		    c = getc ( input ) ;
+		    c = getc(input);
-		    if ( !octal_digit ( c ) ) {
+		    if (!octal_digit(c)) {
-			is_fatal = 0 ;
+			is_fatal = 0;
-			input_error ( "Invalid escape sequence" ) ;
+			input_error("Invalid escape sequence");
-			c = '0' ;
+			c = '0';
+		    }
-		    e = 8 * e + ( c - '0' ) ;
+		    e = 8 * e + (c - '0');
-		    c = getc ( input ) ;
+		    c = getc(input);
-		    if ( !octal_digit ( c ) ) {
+		    if (!octal_digit(c)) {
-			is_fatal = 0 ;
+			is_fatal = 0;
-			input_error ( "Invalid escape sequence" ) ;
+			input_error("Invalid escape sequence");
-			c = '0' ;
+			c = '0';
+		    }
-		    e = 8 * e + ( c - '0' ) ;
+		    e = 8 * e + (c - '0');
-		    c = e ;
+		    c = e;
-		    if ( c >= 256 ) {
+		    if (c >= 256) {
-			is_fatal = 0 ;
+			is_fatal = 0;
-			input_error ( "Invalid escape sequence" ) ;
+			input_error("Invalid escape sequence");
-			c = 0 ;
+			c = 0;
+		    }
+		}
+	    }
-	    if ( c == EOF ) {
+	    if (c == EOF) {
-		is_fatal = 0 ;
+		is_fatal = 0;
-		input_error ( "End of file in string" ) ;
+		input_error("End of file in string");
-		word_type = INPUT_EOF ;
+		word_type = INPUT_EOF;
-		pending = EOF ;
+		pending = EOF;
-		return ;
+		return;
+	    }
-	    if ( !ignore ) *( p++ ) = ( char ) c ;
+	    if (!ignore)*(p++) = (char)c;
-	} while ( c != '"' || escaped ) ;
+	} while (c != '"' || escaped);
-	*( --p ) = 0 ;
+	*(--p) = 0;
 #if 0
-	c = getc ( input ) ;
+	c = getc(input);
-	if ( c == '\n' ) crt_line_no++ ;
+	if (c == '\n')crt_line_no++;
-	if ( !terminator ( c ) ) {
+	if (!terminator(c)) {
-	    is_fatal = 0 ;
+	    is_fatal = 0;
-	    input_error ( "Terminator character expected" ) ;
+	    input_error("Terminator character expected");
+	}
-	pending = c ;
+	pending = c;
 #endif
-	word = word_buff ;
+	word = word_buff;
-	word_length = ( int ) ( p - word ) ;
+	word_length = (int)(p - word);
-	word_type = INPUT_STRING ;
+	word_type = INPUT_STRING;
-	return ;
+	return;
+    }
     /* Check for words */
-    if ( alpha ( c ) ) {
+    if (alpha(c)) {
-	p = word_buff ;
+	p = word_buff;
 	do {
-	    *( p++ ) = ( char ) c ;
+	    *(p++) = (char)c;
-	    c = getc ( input ) ;
+	    c = getc(input);
-	    if ( c == '\n' ) crt_line_no++ ;
+	    if (c == '\n')crt_line_no++;
-	} while ( alphanum ( c ) ) ;
+	} while (alphanum(c));
-	*p = 0 ;
+	*p = 0;
-	if ( !terminator ( c ) ) {
+	if (!terminator(c)) {
-	    is_fatal = 0 ;
+	    is_fatal = 0;
-	    input_error ( "Terminator character expected" ) ;
+	    input_error("Terminator character expected");
+	}
-	pending = c ;
+	pending = c;
-	word = word_buff ;
+	word = word_buff;
-	word_type = INPUT_WORD ;
+	word_type = INPUT_WORD;
-	return ;
+	return;
+    }
     /* Check for bars */
-    if ( c == '|' ) {
+    if (c == '|') {
-	c = getc ( input ) ;
+	c = getc(input);
-	if ( c == '\n' ) crt_line_no++ ;
+	if (c == '\n')crt_line_no++;
-	if ( !terminator ( c ) ) {
+	if (!terminator(c)) {
-	    is_fatal = 0 ;
+	    is_fatal = 0;
-	    input_error ( "Terminator character expected" ) ;
+	    input_error("Terminator character expected");
+	}
-	pending = c ;
+	pending = c;
-	word = "|"  ;
+	word = "|" ;
-	word_type = INPUT_BAR ;
+	word_type = INPUT_BAR;
-	return ;
+	return;
+    }
     /* Check for a single dash and arrow */
-    if ( c == '-' ) {
+    if (c == '-') {
-	c = getc ( input ) ;
+	c = getc(input);
-	if ( c == '\n' ) crt_line_no++ ;
+	if (c == '\n')crt_line_no++;
-	if ( terminator ( c ) ) {
+	if (terminator(c)) {
-	    pending = c ;
+	    pending = c;
-	    word = "-"  ;
+	    word = "-" ;
-	    word_type = INPUT_BLANK ;
+	    word_type = INPUT_BLANK;
-	    return ;
+	    return;
+	}
-	if ( func_input && c == '>' ) {
+	if (func_input && c == '>') {
-	    pending = 0 ;
+	    pending = 0;
-	    word = "->" ;
+	    word = "->";
-	    word_type = INPUT_ARROW ;
+	    word_type = INPUT_ARROW;
-	    return ;
+	    return;
+	}
-	negate = 1 ;
+	negate = 1;
+    }
     /* Step over any signs */
-    while ( c == '-' || c == '+' ) {
+    while (c == '-' || c == '+') {
-	if ( c == '-' ) negate = 1 - negate ;
+	if (c == '-')negate = 1 - negate;
-	c = getc ( input ) ;
+	c = getc(input);
-	if ( c == '\n' ) crt_line_no++ ;
+	if (c == '\n')crt_line_no++;
+    }
     /* Check for numbers */
-    if ( c == '0' ) {
+    if (c == '0') {
-	base = 8 ;
+	base = 8;
-	c = getc ( input ) ;
+	c = getc(input);
-	if ( c == '\n' ) crt_line_no++ ;
+	if (c == '\n')crt_line_no++;
-	if ( terminator ( c ) ) {
+	if (terminator(c)) {
-	    pending = c ;
+	    pending = c;
-	    word = "0" ;
+	    word = "0";
-	    word_type = INPUT_NUMBER ;
+	    word_type = INPUT_NUMBER;
-	    return ;
+	    return;
+	}
-	if ( c == 'x' || c == 'X' ) {
+	if (c == 'x' || c == 'X') {
-	    base = 16 ;
+	    base = 16;
-	    c = getc ( input ) ;
+	    c = getc(input);
-	    if ( c == '\n' ) crt_line_no++ ;
+	    if (c == '\n')crt_line_no++;
+	}
-    } else if ( !dec_digit ( c ) ) {
+    } else if (!dec_digit(c)) {
-	is_fatal = 0 ;
+	is_fatal = 0;
-	input_error ( "Illegal character, %c", ( unsigned char ) c ) ;
+	input_error("Illegal character, %c",(unsigned char)c);
-	pending = 0 ;
+	pending = 0;
-	read_word () ;
+	read_word();
-	return ;
+	return;
+    }
     /* Set up buffer */
-    p = word_buff + BUFFSIZE ;
+    p = word_buff + BUFFSIZE;
-    *( --p ) = 0 ;
+    *(--p) = 0;
-    *( --p ) = '0' ;
+    *(--p) = '0';
-    *( --p ) = 0 ;
+    *(--p) = 0;
     /* Read the number */
     do {
-	unsigned n ;
+	unsigned n;
-	if ( dec_digit ( c ) ) {
+	if (dec_digit(c)) {
-	    n = ( unsigned ) ( c - '0' ) ;
+	    n = (unsigned)(c - '0');
-	} else if ( c >= 'A' && c <= 'F' ) {
+	} else if (c >= 'A' && c <= 'F') {
-	    n = 10 + ( unsigned ) ( c - 'A' ) ;
+	    n = 10 + (unsigned)(c - 'A');
-	} else if ( c >= 'a' && c <= 'f' ) {
+	} else if (c >= 'a' && c <= 'f') {
-	    n = 10 + ( unsigned ) ( c - 'a' ) ;
+	    n = 10 + (unsigned)(c - 'a');
 	} else {
-	    is_fatal = 0 ;
+	    is_fatal = 0;
-	    input_error ( "Illegal digit, %c", ( unsigned char ) c ) ;
+	    input_error("Illegal digit, %c",(unsigned char)c);
-	    n = 0 ;
+	    n = 0;
+	}
-	if ( n >= base ) {
+	if (n >= base) {
-	    is_fatal = 0 ;
+	    is_fatal = 0;
-	    input_error ( "Illegal digit, %c", ( unsigned char ) c ) ;
+	    input_error("Illegal digit, %c",(unsigned char)c);
-	    n = 0 ;
+	    n = 0;
+	}
-	if ( really_analyse ) {
+	if (really_analyse) {
-	    p = word_buff + ( BUFFSIZE - 2 ) ;
+	    p = word_buff + (BUFFSIZE - 2);
 	    do {
-		if ( *p == 0 ) {
+		if (*p == 0) {
-		    *( p - 1 ) = 0 ;
+		    *(p - 1) = 0;
 		} else {
-		    n += base * ( unsigned ) ( *p - '0' ) ;
+		    n += base *(unsigned)(*p - '0');
+		}
-		*p = ( char ) ( '0' + ( n & 7 ) ) ;
+		*p = (char)('0' + (n & 7));
-		n >>= 3 ;
+		n >>= 3;
-		p-- ;
+		p--;
-	    } while ( n || *p ) ;
+	    } while (n || *p);
+	}
-	c = getc ( input ) ;
+	c = getc(input);
-	if ( c == '\n' ) crt_line_no++ ;
+	if (c == '\n')crt_line_no++;
-    } while ( !terminator ( c ) ) ;
+    } while (!terminator(c));
     /* Find the start of the number */
-    if ( really_analyse ) {
+    if (really_analyse) {
 	for ( p = word_buff + ( BUFFSIZE - 2 ) ; *p ; p-- ) /* empty */ ;
-	if ( negate ) *( p-- ) = '-' ;
+	if (negate)*(p--) = '-';
+    }
-    pending = c ;
+    pending = c;
-    word = p + 1 ;
+    word = p + 1;
-    if ( streq ( word, "-0" ) ) word = "0" ;
+    if (streq(word, "-0"))word = "0";
-    word_type = INPUT_NUMBER ;
+    word_type = INPUT_NUMBER;
-    return ;
+    return;
+}
 /*
     HOW MANY WORDS TO THE NEXT CLOSE BRACKET?
     unmatched by an open bracket is read.  The routine returns the
     number of word read at the highest bracket level.  (Not currently
     used.)
 */
-long skip_words
+long
-    PROTO_Z ()
+skip_words(void)
+{
-    long n = 0 ;
+    long n = 0;
-    int level = 1 ;
+    int level = 1;
-    really_analyse = 0 ;
+    really_analyse = 0;
-    while ( level ) {
+    while (level) {
-	read_word () ;
+	read_word();
-	switch ( word_type ) {
+	switch (word_type) {
-	    case INPUT_OPEN : level++ ; break ;
+	    case INPUT_OPEN: level++; break;
-	    case INPUT_CLOSE : level-- ; break ;
+	    case INPUT_CLOSE: level--; break;
-	    case INPUT_EOF : {
+	    case INPUT_EOF: {
-		input_error ( "Unexpected end of file" ) ;
+		input_error("Unexpected end of file");
-		return ( n ) ;
+		return(n);
+	    }
+	}
-	if ( level == 1 ) n++ ;
+	if (level == 1)n++;
+    }
-    really_analyse = 1 ;
+    really_analyse = 1;
-    return ( n ) ;
+    return(n);
+}
 /*
     STORE THE CURRENT POSITION
     The current position in the input file is stored in p.
 */
-void store_position
+void
-    PROTO_N ( ( p ) )
-    PROTO_T ( position *p )
+store_position(position *p)
+{
-    p->line = crt_line_no ;
+    p->line = crt_line_no;
-    p->posn = ftell ( input ) ;
+    p->posn = ftell(input);
-    p->pending = pending ;
+    p->pending = pending;
-    p->ahead = looked_ahead ;
+    p->ahead = looked_ahead;
-    return ;
+    return;
+}
 /*
     SET THE CURRENT POSITION
     The position in the input file is set from p.
 */
-void set_position
+void
-    PROTO_N ( ( p ) )
-    PROTO_T ( position *p )
+set_position(position *p)
+{
-    crt_line_no = p->line ;
+    crt_line_no = p->line;
-    pending = p->pending ;
+    pending = p->pending;
-    looked_ahead = p->ahead ;
+    looked_ahead = p->ahead;
-    if ( fseek ( input, p->posn, SEEK_SET ) ) {
+    if (fseek(input, p->posn, SEEK_SET)) {
-	fatal_error ( "Illegal seek command" ) ;
+	fatal_error("Illegal seek command");
+    }
-    return ;
+    return;
+}

Subversion Repositories tendra.SVN

(root)/branches/tendra5/src/tools/tnc/analyser.c – Rev 5 → 6