fortranscanner.cpp File Reference

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <assert.h>
#include <ctype.h>
#include <qarray.h>
#include <qstack.h>
#include <qregexp.h>
#include <qfile.h>
#include <qmap.h>
#include "fortranscanner.h"
#include "entry.h"
#include "message.h"
#include "config.h"
#include "doxygen.h"
#include "util.h"
#include "defargs.h"
#include "language.h"
#include "commentscan.h"
#include "fortrancode.h"
#include "pre.h"
#include "arguments.h"

Go to the source code of this file.

Classes
struct	yy_buffer_state
struct	yy_trans_info
struct	SymbolModifiers
	Holds modifiers (ie attributes) for one symbol (variable, function, etc) More...
struct	CommentInPrepass

Macros
#define	YY_INT_ALIGNED   short int
#define	yy_create_buffer   fortranscannerYY_create_buffer
#define	yy_delete_buffer   fortranscannerYY_delete_buffer
#define	yy_flex_debug   fortranscannerYY_flex_debug
#define	yy_init_buffer   fortranscannerYY_init_buffer
#define	yy_flush_buffer   fortranscannerYY_flush_buffer
#define	yy_load_buffer_state   fortranscannerYY_load_buffer_state
#define	yy_switch_to_buffer   fortranscannerYY_switch_to_buffer
#define	yyin   fortranscannerYYin
#define	yyleng   fortranscannerYYleng
#define	yylex   fortranscannerYYlex
#define	yylineno   fortranscannerYYlineno
#define	yyout   fortranscannerYYout
#define	yyrestart   fortranscannerYYrestart
#define	yytext   fortranscannerYYtext
#define	yywrap   fortranscannerYYwrap
#define	yyalloc   fortranscannerYYalloc
#define	yyrealloc   fortranscannerYYrealloc
#define	yyfree   fortranscannerYYfree
#define	FLEX_SCANNER
#define	YY_FLEX_MAJOR_VERSION   2
#define	YY_FLEX_MINOR_VERSION   5
#define	YY_FLEX_SUBMINOR_VERSION   35
#define	FLEX_BETA
#define	FLEXINT_H
#define	INT8_MIN   (-128)
#define	INT16_MIN   (-32767-1)
#define	INT32_MIN   (-2147483647-1)
#define	INT8_MAX   (127)
#define	INT16_MAX   (32767)
#define	INT32_MAX   (2147483647)
#define	UINT8_MAX   (255U)
#define	UINT16_MAX   (65535U)
#define	UINT32_MAX   (4294967295U)
#define	yyconst
#define	YY_NULL   0
#define	YY_SC_TO_UI(c)   ((unsigned int) (unsigned char) c)
#define	BEGIN   (yy_start) = 1 + 2 *
#define	YY_START   (((yy_start) - 1) / 2)
#define	YYSTATE   YY_START
#define	YY_STATE_EOF(state)   (YY_END_OF_BUFFER + state + 1)
#define	YY_NEW_FILE   fortranscannerYYrestart(fortranscannerYYin )
#define	YY_END_OF_BUFFER_CHAR   0
#define	YY_BUF_SIZE   16384
#define	YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
#define	YY_TYPEDEF_YY_BUFFER_STATE
#define	EOB_ACT_CONTINUE_SCAN   0
#define	EOB_ACT_END_OF_FILE   1
#define	EOB_ACT_LAST_MATCH   2
#define	YY_LESS_LINENO(n)
#define	yyless(n)
#define	unput(c)   yyunput( c, (yytext_ptr) )
#define	YY_TYPEDEF_YY_SIZE_T
#define	YY_STRUCT_YY_BUFFER_STATE
#define	YY_BUFFER_NEW   0
#define	YY_BUFFER_NORMAL   1
#define	YY_BUFFER_EOF_PENDING   2
#define	YY_CURRENT_BUFFER
#define	YY_CURRENT_BUFFER_LVALUE   (yy_buffer_stack)[(yy_buffer_stack_top)]
#define	YY_FLUSH_BUFFER   fortranscannerYY_flush_buffer(YY_CURRENT_BUFFER )
#define	yy_new_buffer   fortranscannerYY_create_buffer
#define	yy_set_interactive(is_interactive)
#define	yy_set_bol(at_bol)
#define	YY_AT_BOL()   (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
#define	fortranscannerYYwrap(n)   1
#define	YY_SKIP_YYWRAP
#define	yytext_ptr   fortranscannerYYtext
#define	YY_DO_BEFORE_ACTION
#define	YY_NUM_RULES   115
#define	YY_END_OF_BUFFER   116
#define	YY_TRAILING_MASK   0x2000
#define	YY_TRAILING_HEAD_MASK   0x4000
#define	REJECT
#define	yymore()   yymore_used_but_not_detected
#define	YY_MORE_ADJ   0
#define	YY_RESTORE_YY_MORE_OFFSET
#define	DBG_CTX(x)   do { } while(0)
#define	YY_NO_INPUT   1
#define	YY_NO_UNISTD_H   1
#define	YY_INPUT(buf, result, max_size)   result=yyread(buf,max_size);
#define	YY_USER_ACTION   yyColNr+=(int)fortranscannerYYleng;
#define	INITIAL   0
#define	Subprog   1
#define	SubprogPrefix   2
#define	Parameterlist   3
#define	SubprogBody   4
#define	SubprogBodyContains   5
#define	Start   6
#define	Comment   7
#define	Module   8
#define	Program   9
#define	ModuleBody   10
#define	ModuleBodyContains   11
#define	AttributeList   12
#define	Variable   13
#define	Initialization   14
#define	ArrayInitializer   15
#define	Typedef   16
#define	TypedefBody   17
#define	TypedefBodyContains   18
#define	InterfaceBody   19
#define	StrIgnore   20
#define	String   21
#define	Use   22
#define	UseOnly   23
#define	ModuleProcedure   24
#define	Prepass   25
#define	DocBlock   26
#define	DocBackLine   27
#define	EndDoc   28
#define	BlockData   29
#define	Prototype   30
#define	PrototypeSubprog   31
#define	PrototypeArgs   32
#define	YY_EXTRA_TYPE   void *
#define	YY_READ_BUF_SIZE   8192
#define	ECHO   do { if (fwrite( fortranscannerYYtext, fortranscannerYYleng, 1, fortranscannerYYout )) {} } while (0)
#define	yyterminate()   return YY_NULL
#define	YY_START_STACK_INCR   25
#define	YY_FATAL_ERROR(msg)   yy_fatal_error( msg )
#define	YY_DECL_IS_OURS   1
#define	YY_DECL   int fortranscannerYYlex (void)
#define	YY_BREAK   break;
#define	YY_RULE_SETUP
#define	YY_EXIT_FAILURE   2
#define	yyless(n)
#define	YYTABLES_NAME   "yytables"

Typedefs
typedef signed char	flex_int8_t
typedef short int	flex_int16_t
typedef int	flex_int32_t
typedef unsigned char	flex_uint8_t
typedef unsigned short int	flex_uint16_t
typedef unsigned int	flex_uint32_t
typedef struct yy_buffer_state *	YY_BUFFER_STATE
typedef size_t	yy_size_t
typedef unsigned char	YY_CHAR
typedef int	yy_state_type

Enumerations
enum	ScanVar { V_IGNORE, V_VARIABLE, V_PARAMETER, V_RESULT }
enum	InterfaceType { IF_NONE, IF_SPECIFIC, IF_GENERIC, IF_ABSTRACT }

Functions
void	fortranscannerYYrestart (FILE *input_file)
void	fortranscannerYY_switch_to_buffer (YY_BUFFER_STATE new_buffer)
YY_BUFFER_STATE	fortranscannerYY_create_buffer (FILE *file, int size)
void	fortranscannerYY_delete_buffer (YY_BUFFER_STATE b)
void	fortranscannerYY_flush_buffer (YY_BUFFER_STATE b)
void	fortranscannerYYpush_buffer_state (YY_BUFFER_STATE new_buffer)
void	fortranscannerYYpop_buffer_state (void)
static void	fortranscannerYYensure_buffer_stack (void)
static void	fortranscannerYY_load_buffer_state (void)
static void	fortranscannerYY_init_buffer (YY_BUFFER_STATE b, FILE *file)
YY_BUFFER_STATE	fortranscannerYY_scan_buffer (char *base, yy_size_t size)
YY_BUFFER_STATE	fortranscannerYY_scan_string (yyconst char *yy_str)
YY_BUFFER_STATE	fortranscannerYY_scan_bytes (yyconst char *bytes, int len)
void *	fortranscannerYYalloc (yy_size_t)
void *	fortranscannerYYrealloc (void *, yy_size_t)
void	fortranscannerYYfree (void *)
static yy_state_type	yy_get_previous_state (void)
static yy_state_type	yy_try_NUL_trans (yy_state_type current_state)
static int	yy_get_next_buffer (void)
static void	yy_fatal_error (yyconst char msg[])
static int	yyread (char *buf, int max_size)
static void	startCommentBlock (bool)
static void	handleCommentBlock (const QCString &doc, bool brief)
static void	subrHandleCommentBlock (const QCString &doc, bool brief)
	Handle parameter description as defined after the declaration of the parameter. More...
static void	subrHandleCommentBlockResult (const QCString &doc, bool brief)
	Handle result description as defined after the declaration of the parameter. More...
static void	addCurrentEntry (int case_insens)
static void	addModule (const char *name, bool isModule=FALSE)
static void	addSubprogram (const char *text)
static void	addInterface (QCString name, InterfaceType type)
static Argument *	getParameter (const QCString &name)
static void	scanner_abort ()
static void	startScope (Entry *scope)
static bool	endScope (Entry *scope, bool isGlobalRoot=FALSE)
static void	resolveModuleProcedures (QList< Entry > &moduleProcedures, Entry *current_root)
static int	getAmpersandAtTheStart (const char *buf, int length)
static int	getAmpOrExclAtTheEnd (const char *buf, int length)
static void	truncatePrepass (int index)
static void	pushBuffer (QCString &buffer)
static void	popBuffer ()
static QCString	extractFromParens (const QCString name)
static CommentInPrepass *	locatePrepassComment (int from, int to)
static void	updateVariablePrepassComment (int from, int to)
static void	newLine ()
static int	yy_init_globals (void)
int	fortranscannerYYlex_destroy (void)
int	fortranscannerYYget_debug (void)
void	fortranscannerYYset_debug (int debug_flag)
YY_EXTRA_TYPE	fortranscannerYYget_extra (void)
void	fortranscannerYYset_extra (YY_EXTRA_TYPE user_defined)
FILE *	fortranscannerYYget_in (void)
void	fortranscannerYYset_in (FILE *in_str)
FILE *	fortranscannerYYget_out (void)
void	fortranscannerYYset_out (FILE *out_str)
int	fortranscannerYYget_leng (void)
char *	fortranscannerYYget_text (void)
int	fortranscannerYYget_lineno (void)
void	fortranscannerYYset_lineno (int line_number)
static void	yyunput (int c, char *buf_ptr)
static void	yy_push_state (int new_state)
static void	yy_pop_state (void)
static int	yy_top_state (void)
int	fortranscannerYYlex (void)
	if (!(yy_init))
	while (1)
static void	yyunput (int c, register char *yy_bp)
static void	yy_fatal_error (yyconst char *msg)
static bool	recognizeFixedForm (const char *contents, FortranFormat format)
static void	insertCharacter (char *contents, int length, int pos, char c)
static const char *	prepassFixedForm (const char *contents)
static void	copyEntry (Entry *dest, Entry *src)
static Argument *	findArgument (Entry *subprog, QCString name, bool byTypeName=FALSE)
static QCString	applyModifiers (QCString typeName, SymbolModifiers &mdfs)
static void	applyModifiers (Argument *arg, SymbolModifiers &mdfs)
static void	applyModifiers (Entry *ent, SymbolModifiers &mdfs)
static void	initParser ()
static void	initEntry ()
static int	max (int a, int b)
static void	parseMain (const char *fileName, const char *fileBuf, Entry *rt, FortranFormat format)

Variables
int	fortranscannerYYleng
FILE *	fortranscannerYYin = (FILE *) 0
FILE *	fortranscannerYYout = (FILE *) 0
static size_t	yy_buffer_stack_top = 0
static size_t	yy_buffer_stack_max = 0
static YY_BUFFER_STATE *	yy_buffer_stack = 0
static char	yy_hold_char
static int	yy_n_chars
static char *	yy_c_buf_p = (char *) 0
static int	yy_init = 0
static int	yy_start = 0
static int	yy_did_buffer_switch_on_eof
int	fortranscannerYYlineno = 1
char *	fortranscannerYYtext
static yyconst flex_int16_t	yy_acclist [6178]
static yyconst flex_int16_t	yy_accept [24249]
static yyconst flex_int32_t	yy_ec [256]
static yyconst flex_int32_t	yy_meta [72]
static yyconst flex_int32_t	yy_base [29670]
static yyconst flex_int16_t	yy_def [29670]
static yyconst flex_int16_t	yy_nxt [209459]
static yyconst flex_int16_t	yy_chk [209459]
int	fortranscannerYY_flex_debug = 0
static yy_state_type *	yy_state_buf =0
static yy_state_type *	yy_state_ptr =0
static char *	yy_full_match
static int	yy_lp
static int	yy_looking_for_trail_begin = 0
static int	yy_full_lp
static int *	yy_full_state
static const char *	directionStrs []
static const char *	directionParam []
static ParserInterface *	g_thisParser
static const char *	inputString
static int	inputPosition
static bool	isFixedForm
static QCString	inputStringPrepass
	Input string for prepass of line cont. '&'. More...
static QCString	inputStringSemi
	Input string after command separetor ';'. More...
static unsigned int	inputPositionPrepass
static int	lineCountPrepass = 0
static QList< Entry >	subrCurrent
static QList< CommentInPrepass >	comments
YY_BUFFER_STATE *	include_stack = NULL
int	include_stack_ptr = 0
int	include_stack_cnt = 0
static QFile	inputFile
static QCString	yyFileName
static int	yyLineNr = 1
static int	yyColNr = 0
static Entry *	current_root = 0
static Entry *	global_root = 0
static Entry *	file_root = 0
static Entry *	current = 0
static Entry *	last_entry = 0
static ScanVar	v_type = V_IGNORE
static QList< Entry >	moduleProcedures
static QCString	docBlock
static bool	docBlockInBody = FALSE
static bool	docBlockJavaStyle
static MethodTypes	mtype
static bool	gstat
static Specifier	virt
static QCString	debugStr
static QCString	result
static Argument *	parameter
static QCString	argType
static QCString	argName
static QCString	initializer
static int	initializerArrayScope
static int	initializerScope
static QCString	useModuleName
static Protection	defaultProtection
static Protection	typeProtection
static int	typeMode = false
static InterfaceType	ifType = IF_NONE
static bool	functionLine = FALSE
static char	stringStartSymbol
static bool	parsingPrototype = FALSE
static SymbolModifiers	currentModifiers
	Accumulated modifiers of current statement, eg variable declaration. More...
static QMap< Entry *, QMap< QCString, SymbolModifiers > >	modifiers
	Holds program scope->symbol name->symbol modifiers. More...
static int	yy_start_stack_ptr = 0
static int	yy_start_stack_depth = 0
static int *	yy_start_stack = NULL
	YY_DECL
register char *	yy_cp
register char *	yy_bp
register int	yy_act

Macro Definition Documentation

#define ArrayInitializer   15

Definition at line 56728 of file fortranscanner.cpp.

#define AttributeList   12

Definition at line 56725 of file fortranscanner.cpp.

#define BEGIN   (yy_start) = 1 + 2 *

Definition at line 144 of file fortranscanner.cpp.

#define BlockData   29

Definition at line 56742 of file fortranscanner.cpp.

#define Comment   7

Definition at line 56720 of file fortranscanner.cpp.

#define DBG_CTX

(

x

)

do { } while(0)

Definition at line 56507 of file fortranscanner.cpp.

#define DocBackLine   27

Definition at line 56740 of file fortranscanner.cpp.

#define DocBlock   26

Definition at line 56739 of file fortranscanner.cpp.

#define ECHO   do { if (fwrite( fortranscannerYYtext, fortranscannerYYleng, 1, fortranscannerYYout )) {} } while (0)

Definition at line 56842 of file fortranscanner.cpp.

#define EndDoc   28

Definition at line 56741 of file fortranscanner.cpp.

#define EOB_ACT_CONTINUE_SCAN   0

Definition at line 179 of file fortranscanner.cpp.

#define EOB_ACT_END_OF_FILE   1

Definition at line 180 of file fortranscanner.cpp.

#define EOB_ACT_LAST_MATCH   2

Definition at line 181 of file fortranscanner.cpp.

#define FLEX_BETA

Definition at line 33 of file fortranscanner.cpp.

#define FLEX_SCANNER

Definition at line 28 of file fortranscanner.cpp.

#define FLEXINT_H

Definition at line 49 of file fortranscanner.cpp.

#define fortranscannerYYwrap

(

n

)

1

Definition at line 354 of file fortranscanner.cpp.

#define INITIAL   0

fortran parsing states comment parsing states prototype parsing

Definition at line 56713 of file fortranscanner.cpp.

#define Initialization   14

Definition at line 56727 of file fortranscanner.cpp.

#define INT16_MAX   (32767)

Definition at line 92 of file fortranscanner.cpp.

#define INT16_MIN   (-32767-1)

Definition at line 83 of file fortranscanner.cpp.

#define INT32_MAX   (2147483647)

Definition at line 95 of file fortranscanner.cpp.

#define INT32_MIN   (-2147483647-1)

Definition at line 86 of file fortranscanner.cpp.

#define INT8_MAX   (127)

Definition at line 89 of file fortranscanner.cpp.

#define INT8_MIN   (-128)

Definition at line 80 of file fortranscanner.cpp.

#define InterfaceBody   19

Definition at line 56732 of file fortranscanner.cpp.

#define Module   8

Definition at line 56721 of file fortranscanner.cpp.

#define ModuleBody   10

Definition at line 56723 of file fortranscanner.cpp.

#define ModuleBodyContains   11

Definition at line 56724 of file fortranscanner.cpp.

#define ModuleProcedure   24

Definition at line 56737 of file fortranscanner.cpp.

#define Parameterlist   3

Definition at line 56716 of file fortranscanner.cpp.

#define Prepass   25

Definition at line 56738 of file fortranscanner.cpp.

#define Program   9

Definition at line 56722 of file fortranscanner.cpp.

#define Prototype   30

Definition at line 56743 of file fortranscanner.cpp.

#define PrototypeArgs   32

Definition at line 56745 of file fortranscanner.cpp.

#define PrototypeSubprog   31

Definition at line 56744 of file fortranscanner.cpp.

#define REJECT

Value:

{ \
*yy_cp = (yy_hold_char); /* undo effects of setting up fortranscannerYYtext */ \
yy_cp = (yy_full_match); /* restore poss. backed-over text */ \
(yy_lp) = (yy_full_lp); /* restore orig. accepting pos. */ \
(yy_state_ptr) = (yy_full_state); /* restore orig. state */ \
yy_current_state = *(yy_state_ptr); /* restore curr. state */ \
++(yy_lp); \
goto find_rule; \
}

Definition at line 56425 of file fortranscanner.cpp.

#define Start   6

Definition at line 56719 of file fortranscanner.cpp.

#define StrIgnore   20

Definition at line 56733 of file fortranscanner.cpp.

#define String   21

Definition at line 56734 of file fortranscanner.cpp.

#define Subprog   1

Definition at line 56714 of file fortranscanner.cpp.

#define SubprogBody   4

Definition at line 56717 of file fortranscanner.cpp.

#define SubprogBodyContains   5

Definition at line 56718 of file fortranscanner.cpp.

#define SubprogPrefix   2

Definition at line 56715 of file fortranscanner.cpp.

#define Typedef   16

Definition at line 56729 of file fortranscanner.cpp.

#define TypedefBody   17

Definition at line 56730 of file fortranscanner.cpp.

#define TypedefBodyContains   18

Definition at line 56731 of file fortranscanner.cpp.

#define UINT16_MAX   (65535U)

Definition at line 101 of file fortranscanner.cpp.

#define UINT32_MAX   (4294967295U)

Definition at line 104 of file fortranscanner.cpp.

#define UINT8_MAX   (255U)

Definition at line 98 of file fortranscanner.cpp.

#define unput

(

c

)

yyunput( c, (yytext_ptr) )

Definition at line 199 of file fortranscanner.cpp.

#define Use   22

Definition at line 56735 of file fortranscanner.cpp.

#define UseOnly   23

Definition at line 56736 of file fortranscanner.cpp.

#define Variable   13

Definition at line 56726 of file fortranscanner.cpp.

#define YY_AT_BOL

(

)

(YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

Definition at line 350 of file fortranscanner.cpp.

#define YY_BREAK   break;

Definition at line 56921 of file fortranscanner.cpp.

#define YY_BUF_SIZE   16384

Definition at line 163 of file fortranscanner.cpp.

#define YY_BUFFER_EOF_PENDING   2

Definition at line 266 of file fortranscanner.cpp.

#define YY_BUFFER_NEW   0

Definition at line 254 of file fortranscanner.cpp.

#define YY_BUFFER_NORMAL   1

Definition at line 255 of file fortranscanner.cpp.

#define yy_create_buffer   fortranscannerYY_create_buffer

Definition at line 9 of file fortranscanner.cpp.

#define YY_CURRENT_BUFFER

Value:

( (yy_buffer_stack) \
                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
                          : NULL)

Definition at line 282 of file fortranscanner.cpp.

#define YY_CURRENT_BUFFER_LVALUE   (yy_buffer_stack)[(yy_buffer_stack_top)]

Definition at line 289 of file fortranscanner.cpp.

#define YY_DECL   int fortranscannerYYlex (void)

Definition at line 56909 of file fortranscanner.cpp.

#define YY_DECL_IS_OURS   1

Definition at line 56905 of file fortranscanner.cpp.

#define yy_delete_buffer   fortranscannerYY_delete_buffer

Definition at line 10 of file fortranscanner.cpp.

#define YY_DO_BEFORE_ACTION

Value:

(yytext_ptr) = yy_bp; \
	fortranscannerYYleng = (size_t) (yy_cp - yy_bp); \
        (yy_hold_char) = *yy_cp; \
        *yy_cp = '\0'; \
        (yy_c_buf_p) = yy_cp;

Definition at line 378 of file fortranscanner.cpp.

#define YY_END_OF_BUFFER   116

Definition at line 386 of file fortranscanner.cpp.

#define YY_END_OF_BUFFER_CHAR   0

Definition at line 159 of file fortranscanner.cpp.

#define YY_EXIT_FAILURE   2

Definition at line 59235 of file fortranscanner.cpp.

#define YY_EXTRA_TYPE   void *

Definition at line 56756 of file fortranscanner.cpp.

#define YY_FATAL_ERROR

(

msg

)

yy_fatal_error( msg )

Definition at line 56896 of file fortranscanner.cpp.

#define yy_flex_debug   fortranscannerYY_flex_debug

Definition at line 11 of file fortranscanner.cpp.

#define YY_FLEX_MAJOR_VERSION   2

Definition at line 29 of file fortranscanner.cpp.

#define YY_FLEX_MINOR_VERSION   5

Definition at line 30 of file fortranscanner.cpp.

#define YY_FLEX_SUBMINOR_VERSION   35

Definition at line 31 of file fortranscanner.cpp.

#define yy_flush_buffer   fortranscannerYY_flush_buffer

Definition at line 13 of file fortranscanner.cpp.

#define YY_FLUSH_BUFFER   fortranscannerYY_flush_buffer(YY_CURRENT_BUFFER )

Definition at line 318 of file fortranscanner.cpp.

#define yy_init_buffer   fortranscannerYY_init_buffer

Definition at line 12 of file fortranscanner.cpp.

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

Definition at line 56667 of file fortranscanner.cpp.

#define YY_INT_ALIGNED   short int

Definition at line 5 of file fortranscanner.cpp.

#define YY_LESS_LINENO

(

n

)

Definition at line 183 of file fortranscanner.cpp.

#define yy_load_buffer_state   fortranscannerYY_load_buffer_state

Definition at line 14 of file fortranscanner.cpp.

#define YY_MORE_ADJ   0

Definition at line 56437 of file fortranscanner.cpp.

#define yy_new_buffer   fortranscannerYY_create_buffer

Definition at line 328 of file fortranscanner.cpp.

#define YY_NEW_FILE   fortranscannerYYrestart(fortranscannerYYin )

Definition at line 157 of file fortranscanner.cpp.

#define YY_NO_INPUT   1

Definition at line 56509 of file fortranscanner.cpp.

#define YY_NO_UNISTD_H   1

Definition at line 56510 of file fortranscanner.cpp.

#define YY_NULL   0

Definition at line 131 of file fortranscanner.cpp.

#define YY_NUM_RULES   115

Definition at line 385 of file fortranscanner.cpp.

#define YY_READ_BUF_SIZE   8192

Definition at line 56834 of file fortranscanner.cpp.

#define YY_RESTORE_YY_MORE_OFFSET

Definition at line 56438 of file fortranscanner.cpp.

#define YY_RULE_SETUP

Value:

if ( fortranscannerYYleng > 0 ) \
		YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
                                (fortranscannerYYtext[fortranscannerYYleng - 1] == '\n'); \
	YY_USER_ACTION

Definition at line 56924 of file fortranscanner.cpp.

#define YY_SC_TO_UI

(

c

)

((unsigned int) (unsigned char) c)

Definition at line 138 of file fortranscanner.cpp.

#define yy_set_bol

(

at_bol

)

Value:

{ \
	if ( ! YY_CURRENT_BUFFER ){\
        fortranscannerYYensure_buffer_stack (); \
		YY_CURRENT_BUFFER_LVALUE =    \
            fortranscannerYY_create_buffer(fortranscannerYYin,YY_BUF_SIZE ); \
        } \
	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
        }

Definition at line 340 of file fortranscanner.cpp.

#define yy_set_interactive

(

is_interactive

)

Value:

{ \
	if ( ! YY_CURRENT_BUFFER ){ \
        fortranscannerYYensure_buffer_stack (); \
		YY_CURRENT_BUFFER_LVALUE =    \
            fortranscannerYY_create_buffer(fortranscannerYYin,YY_BUF_SIZE ); \
        } \
	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
        }

Definition at line 330 of file fortranscanner.cpp.

#define YY_SKIP_YYWRAP

Definition at line 355 of file fortranscanner.cpp.

#define YY_START   (((yy_start) - 1) / 2)

Definition at line 150 of file fortranscanner.cpp.

#define YY_START_STACK_INCR   25

Definition at line 56891 of file fortranscanner.cpp.

#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))

Definition at line 168 of file fortranscanner.cpp.

#define YY_STATE_EOF

(

state

)

(YY_END_OF_BUFFER + state + 1)

Definition at line 154 of file fortranscanner.cpp.

#define YY_STRUCT_YY_BUFFER_STATE

Definition at line 207 of file fortranscanner.cpp.

#define yy_switch_to_buffer   fortranscannerYY_switch_to_buffer

Definition at line 15 of file fortranscanner.cpp.

#define YY_TRAILING_HEAD_MASK   0x4000

Definition at line 56424 of file fortranscanner.cpp.

#define YY_TRAILING_MASK   0x2000

Definition at line 56423 of file fortranscanner.cpp.

#define YY_TYPEDEF_YY_BUFFER_STATE

Definition at line 171 of file fortranscanner.cpp.

#define YY_TYPEDEF_YY_SIZE_T

Definition at line 202 of file fortranscanner.cpp.

#define YY_USER_ACTION   yyColNr+=(int)fortranscannerYYleng;

Definition at line 56668 of file fortranscanner.cpp.

#define yyalloc   fortranscannerYYalloc

Definition at line 24 of file fortranscanner.cpp.

#define yyconst

Definition at line 127 of file fortranscanner.cpp.

#define yyfree   fortranscannerYYfree

Definition at line 26 of file fortranscanner.cpp.

#define yyin   fortranscannerYYin

Definition at line 16 of file fortranscanner.cpp.

#define yyleng   fortranscannerYYleng

Definition at line 17 of file fortranscanner.cpp.

#define yyless

(

n

)

Value:

do \
                { \
                /* Undo effects of setting up fortranscannerYYtext. */ \
        int yyless_macro_arg = (n); \
        YY_LESS_LINENO(yyless_macro_arg);\
                *yy_cp = (yy_hold_char); \
		YY_RESTORE_YY_MORE_OFFSET \
                (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
		YY_DO_BEFORE_ACTION; /* set up fortranscannerYYtext again */ \
                } \
	while ( 0 )

Definition at line 59247 of file fortranscanner.cpp.

#define yyless

(

n

)

Value:

do \
                { \
                /* Undo effects of setting up fortranscannerYYtext. */ \
        int yyless_macro_arg = (n); \
        YY_LESS_LINENO(yyless_macro_arg);\
		fortranscannerYYtext[fortranscannerYYleng] = (yy_hold_char); \
                (yy_c_buf_p) = fortranscannerYYtext + yyless_macro_arg; \
                (yy_hold_char) = *(yy_c_buf_p); \
                *(yy_c_buf_p) = '\0'; \
		fortranscannerYYleng = yyless_macro_arg; \
                } \
	while ( 0 )

Definition at line 59247 of file fortranscanner.cpp.

#define yylex   fortranscannerYYlex

Definition at line 18 of file fortranscanner.cpp.

#define yylineno   fortranscannerYYlineno

Definition at line 19 of file fortranscanner.cpp.

#define yymore

(

)

yymore_used_but_not_detected

Definition at line 56436 of file fortranscanner.cpp.

#define yyout   fortranscannerYYout

Definition at line 20 of file fortranscanner.cpp.

#define yyrealloc   fortranscannerYYrealloc

Definition at line 25 of file fortranscanner.cpp.

#define yyrestart   fortranscannerYYrestart

Definition at line 21 of file fortranscanner.cpp.

#define YYSTATE   YY_START

Definition at line 151 of file fortranscanner.cpp.

#define YYTABLES_NAME   "yytables"

Definition at line 59453 of file fortranscanner.cpp.

#define yyterminate

(

)

return YY_NULL

Definition at line 56886 of file fortranscanner.cpp.

#define yytext   fortranscannerYYtext

Definition at line 22 of file fortranscanner.cpp.

#define yytext_ptr   fortranscannerYYtext

Definition at line 368 of file fortranscanner.cpp.

#define yywrap   fortranscannerYYwrap

Definition at line 23 of file fortranscanner.cpp.

Typedef Documentation

typedef short int flex_int16_t

Definition at line 71 of file fortranscanner.cpp.

typedef int flex_int32_t

Definition at line 72 of file fortranscanner.cpp.

typedef signed char flex_int8_t

Definition at line 70 of file fortranscanner.cpp.

typedef unsigned short int flex_uint16_t

Definition at line 74 of file fortranscanner.cpp.

typedef unsigned int flex_uint32_t

Definition at line 75 of file fortranscanner.cpp.

typedef unsigned char flex_uint8_t

Definition at line 73 of file fortranscanner.cpp.

typedef struct yy_buffer_state* YY_BUFFER_STATE

Definition at line 172 of file fortranscanner.cpp.

typedef unsigned char YY_CHAR

Definition at line 357 of file fortranscanner.cpp.

typedef size_t yy_size_t

Definition at line 203 of file fortranscanner.cpp.

typedef int yy_state_type

Definition at line 361 of file fortranscanner.cpp.

Enumeration Type Documentation

enum InterfaceType

Enumerator
IF_NONE
IF_SPECIFIC
IF_GENERIC
IF_ABSTRACT

Definition at line 56513 of file fortranscanner.cpp.

{ IF_NONE, IF_SPECIFIC, IF_GENERIC, IF_ABSTRACT };

enum ScanVar

Enumerator
V_IGNORE
V_VARIABLE
V_PARAMETER
V_RESULT

Definition at line 56512 of file fortranscanner.cpp.

{ V_IGNORE, V_VARIABLE, V_PARAMETER, V_RESULT};

Function Documentation

static void addCurrentEntry ( int  case_insens )

static

adds current entry to current_root and creates new current

Definition at line 60356 of file fortranscanner.cpp.

{
  if (case_insens) current->name = current->name.lower();
  //printf("===Adding entry %s to %s\n", current->name.data(), current_root->name.data());
  current_root->addSubEntry(current);
  last_entry = current;
  current = new Entry ;
  initEntry();
}

static void addInterface ( QCString  name, InterfaceType  type  )

static

Adds interface to the root entry.

Note

Code was brought to this procedure from the parser, because there was/is idea to use it in several parts of the parser.

Definition at line 60420 of file fortranscanner.cpp.

{
  if (YY_START == Start)
  {
    addModule(NULL);
    yy_push_state(ModuleBody); //anon program
  }

  current->section = Entry::CLASS_SEC; // was Entry::INTERFACE_SEC;
  current->spec = Entry::Interface;
  current->name = name;

  switch (type)
  {
    case IF_ABSTRACT:
      current->type = "abstract";
      break;

    case IF_GENERIC:
      current->type = "generic";
      break;

    case IF_SPECIFIC:
    case IF_NONE:
    default:
      current->type = "";
  }

  /* if type is part of a module, mod name is necessary for output */
  if ((current_root) && 
      (current_root->section ==  Entry::CLASS_SEC ||
       current_root->section ==  Entry::NAMESPACE_SEC)) 
  {
    current->name= current_root->name + "::" + current->name;
  }

  current->fileName = yyFileName;
  current->bodyLine  = yyLineNr; 
  current->startLine  = yyLineNr;
  addCurrentEntry(1);
}

static void addModule ( const char *  name, bool  isModule = FALSE  )

static

Definition at line 60368 of file fortranscanner.cpp.

{
  DBG_CTX((stderr, "0=========> got module %s\n", name));

  if (isModule)
    current->section = Entry::NAMESPACE_SEC;
  else
    current->section = Entry::FUNCTION_SEC;

  if (name!=NULL)
  {
    current->name = name;
  } 
  else
  {
    QCString fname = yyFileName;
    int index = max(fname.findRev('/'), fname.findRev('\\'));
    fname = fname.right(fname.length()-index-1);
    fname = fname.prepend("__").append("__");
    current->name = fname;
  }
  current->type = "program";
  current->fileName  = yyFileName;
  current->bodyLine  = yyLineNr; // used for source reference
  current->startLine  = yyLineNr;
  current->protection = Public ;
  addCurrentEntry(1);
  startScope(last_entry);
}

static void addSubprogram ( const char *  text )

static

Definition at line 60399 of file fortranscanner.cpp.

{
  DBG_CTX((stderr,"1=========> got subprog, type: %s\n",text)); 
  subrCurrent.prepend(current);
  current->section = Entry::FUNCTION_SEC ;
  QCString subtype = text; subtype=subtype.lower().stripWhiteSpace();
  functionLine = (subtype.find("function") != -1);
  current->type += " " + subtype;
  current->type = current->type.stripWhiteSpace();
  current->fileName  = yyFileName;
  current->bodyLine  = yyLineNr; // used for source reference start of body of routine
  current->startLine  = yyLineNr; // used for source reference start of definition
  current->args.resize(0);
  current->argList->clear();
  docBlock.resize(0);
}

static QCString applyModifiers ( QCString  typeName, SymbolModifiers &  mdfs  )

static

Find function with given name in entry.

Apply modifiers stored in mdfs to the typeName string.

Definition at line 60063 of file fortranscanner.cpp.

{
  if (!mdfs.dimension.isNull()) 
  {
    if (!typeName.isEmpty()) typeName += ", ";
    typeName += mdfs.dimension;
  }
  if (mdfs.direction!=SymbolModifiers::NONE_D) 
  {
    if (!typeName.isEmpty()) typeName += ", ";
    typeName += directionStrs[mdfs.direction];
  }
  if (mdfs.optional) 
  {
    if (!typeName.isEmpty()) typeName += ", ";
    typeName += "optional";
  }
  if (mdfs.allocatable) 
  {
    if (!typeName.isEmpty()) typeName += ", ";
    typeName += "allocatable";
  }
  if (mdfs.external) 
  {
    if (!typeName.contains("external"))
    {
      if (!typeName.isEmpty()) typeName += ", ";
      typeName += "external";
    }
  }
  if (mdfs.intrinsic) 
  {
    if (!typeName.isEmpty()) typeName += ", ";
    typeName += "intrinsic";
  }
  if (mdfs.parameter) 
  {
    if (!typeName.isEmpty()) typeName += ", ";
    typeName += "parameter";
  }
  if (mdfs.pointer) 
  {
    if (!typeName.isEmpty()) typeName += ", ";
    typeName += "pointer";
  }
  if (mdfs.target) 
  {
    if (!typeName.isEmpty()) typeName += ", ";
    typeName += "target";
  }
  if (mdfs.save) 
  {
    if (!typeName.isEmpty()) typeName += ", ";
    typeName += "save";
  }
  if (mdfs.deferred) 
  {
    if (!typeName.isEmpty()) typeName += ", ";
    typeName += "deferred";
  }
  if (mdfs.nonoverridable) 
  {
    if (!typeName.isEmpty()) typeName += ", ";
    typeName += "non_overridable";
  }
  if (mdfs.nopass) 
  {
    if (!typeName.isEmpty()) typeName += ", ";
    typeName += "nopass";
  }
  if (mdfs.pass) 
  {
    if (!typeName.isEmpty()) typeName += ", ";
    typeName += "pass";
    if (!mdfs.passVar.isEmpty())
      typeName += "(" + mdfs.passVar + ")";
  }
  if (mdfs.protection == SymbolModifiers::PUBLIC)
  {
    if (!typeName.isEmpty()) typeName += ", ";
    typeName += "public";
  }
  else if (mdfs.protection == SymbolModifiers::PRIVATE)
  {
    if (!typeName.isEmpty()) typeName += ", ";
    typeName += "private";
  }
  if (mdfs.protect)
  {
    if (!typeName.isEmpty()) typeName += ", ";
    typeName += "protected";
  }
  if (mdfs.contiguous)
  {
    if (!typeName.isEmpty()) typeName += ", ";
    typeName += "contiguous";
  }
  if (mdfs.volat)
  {
    if (!typeName.isEmpty()) typeName += ", ";
    typeName += "volatile";
  }
  if (mdfs.value)
  {
    if (!typeName.isEmpty()) typeName += ", ";
    typeName += "value";
  }

  return typeName;
}

static void applyModifiers ( Argument *  arg, SymbolModifiers &  mdfs  )

static

Apply modifiers stored in mdfs to the arg argument.

Definition at line 60175 of file fortranscanner.cpp.

{
  QCString tmp = arg->type;
  arg->type = applyModifiers(tmp, mdfs);
}

static void applyModifiers ( Entry *  ent, SymbolModifiers &  mdfs  )

static

Apply modifiers stored in mdfs to the ent entry.

Definition at line 60182 of file fortranscanner.cpp.

{
  QCString tmp = ent->type;
  ent->type = applyModifiers(tmp, mdfs);

  if (mdfs.protection == SymbolModifiers::PUBLIC)
    ent->protection = Public;
  else if (mdfs.protection == SymbolModifiers::PRIVATE)
    ent->protection = Private;
}

static void copyEntry ( Entry *  dest, Entry *  src  )

static

used to copy entry to an interface module procedure

Definition at line 59821 of file fortranscanner.cpp.

{
   dest->type     = src->type;
   dest->fileName = src->fileName;
   dest->startLine = src->startLine;
   dest->bodyLine = src->bodyLine;
   dest->endBodyLine = src->endBodyLine;
   dest->args     = src->args;
   dest->argList  = new ArgumentList(*src->argList);
   dest->doc      = src->doc;
   dest->brief    = src->brief;
}

static bool endScope ( Entry *  scope, bool  isGlobalRoot  )

static

Ends scope in fortran program: may update subprogram arguments or module variable attributes.

See also

startScope()

Definition at line 60209 of file fortranscanner.cpp.

{
  //cout<<"end scope: "<<scope->name<<endl;
  if (current_root->parent() || isGlobalRoot)
  {
    current_root= current_root->parent(); /* end substructure */
  }
  else 
  {
    fprintf(stderr,"parse error in end <scopename>");
    scanner_abort();
    return FALSE;
  }

  // update variables or subprogram arguments with modifiers
  QMap<QCString,SymbolModifiers>& mdfsMap = modifiers[scope];

  if (scope->section == Entry::FUNCTION_SEC) 
  {
    // iterate all symbol modifiers of the scope
    for (QMap<QCString,SymbolModifiers>::Iterator it=mdfsMap.begin(); it!=mdfsMap.end(); it++) 
    {
      //cout<<it.key()<<": "<<it.data()<<endl;
      Argument *arg = findArgument(scope, it.key());

      if (arg)
        applyModifiers(arg, it.data());
    }

    // find return type for function
    //cout<<"RETURN NAME "<<modifiers[current_root][scope->name.lower()].returnName<<endl;
    QCString returnName = modifiers[current_root][scope->name.lower()].returnName.lower();
    if (modifiers[scope].contains(returnName)) 
    {
      scope->type = modifiers[scope][returnName].type; // returning type works
      applyModifiers(scope, modifiers[scope][returnName]); // returning array works
    }

  } 
  if (scope->section == Entry::CLASS_SEC) 
  { // was INTERFACE_SEC
    if (scope->parent()->section == Entry::FUNCTION_SEC) 
    { // interface within function
      // iterate functions of interface and 
      // try to find types for dummy(ie. argument) procedures.
      //cout<<"Search in "<<scope->name<<endl;
      EntryListIterator eli(*scope->children());
      Entry *ce;
      int count = 0;
      int found = FALSE;
      for (;(ce=eli.current());++eli) 
      {
        count++;
        if (ce->section != Entry::FUNCTION_SEC)
          continue;

        Argument *arg = findArgument(scope->parent(), ce->name, TRUE);
        if (arg != 0) 
        {
          // set type of dummy procedure argument to interface
          arg->name = arg->type;
          arg->type = scope->name;
        }
        if (ce->name.lower() == scope->name.lower()) found = TRUE;
      }
      if ((count == 1) && found)
      {
        // clear all modifiers of the scope
        modifiers.remove(scope);
        delete scope->parent()->removeSubEntry(scope);
        scope = 0;
        return TRUE;
      }
    }
  } 
  if (scope->section!=Entry::FUNCTION_SEC) 
  { // not function section 
    // iterate variables: get and apply modifiers
    EntryListIterator eli(*scope->children());
    Entry *ce;
    for (;(ce=eli.current());++eli) 
    {
      if (ce->section != Entry::VARIABLE_SEC && ce->section != Entry::FUNCTION_SEC)
        continue;

      //cout<<ce->name<<", "<<mdfsMap.contains(ce->name.lower())<<mdfsMap.count()<<endl;
      if (mdfsMap.contains(ce->name.lower()))
        applyModifiers(ce, mdfsMap[ce->name.lower()]);
    }
  }

  // clear all modifiers of the scope
  modifiers.remove(scope);

  return TRUE;
}

static QCString extractFromParens ( const QCString  name )

static

Extracts string which resides within parentheses of provided string.

Definition at line 59869 of file fortranscanner.cpp.

{
  QCString extracted = name;
  int start = extracted.find("(");
  if (start != -1) 
  {
    extracted.remove(0, start+1);
  }
  int end = extracted.findRev(")");
  if (end != -1) 
  {
    int length = extracted.length();
    extracted.remove(end, length);
  }
  extracted = extracted.stripWhiteSpace();

  return extracted;
}

static Argument* findArgument ( Entry *  subprog, QCString  name, bool  byTypeName = FALSE  )

static

For debugging purposes.

Find argument with given name in subprog entry.

Definition at line 60025 of file fortranscanner.cpp.

{
  QCString cname(name.lower());
  for (unsigned int i=0; i<subprog->argList->count(); i++) 
  {
    Argument *arg = subprog->argList->at(i);
    if ((!byTypeName && arg->name.lower() == cname) ||
        (byTypeName && arg->type.lower() == cname)
       )
    {
      return arg;
    }
  }
  return 0;
}

YY_BUFFER_STATE fortranscannerYY_create_buffer	(	FILE *	file,
		int	size
	)

Allocate and initialize an input buffer state.

Parameters

file	A readable stream.
size	The character buffer size in bytes. When in doubt, use YY_BUF_SIZE.

Returns

the allocated buffer state.

Definition at line 58915 of file fortranscanner.cpp.

{
        YY_BUFFER_STATE b;
    
        b = (YY_BUFFER_STATE) fortranscannerYYalloc(sizeof( struct yy_buffer_state )  );
        if ( ! b )
                YY_FATAL_ERROR( "out of dynamic memory in fortranscannerYY_create_buffer()" );

        b->yy_buf_size = size;

        /* yy_ch_buf has to be 2 characters longer than the size given because
         * we need to put in 2 end-of-buffer characters.
         */
        b->yy_ch_buf = (char *) fortranscannerYYalloc(b->yy_buf_size + 2  );
        if ( ! b->yy_ch_buf )
                YY_FATAL_ERROR( "out of dynamic memory in fortranscannerYY_create_buffer()" );

        b->yy_is_our_buffer = 1;

        fortranscannerYY_init_buffer(b,file );

        return b;
}

void fortranscannerYY_delete_buffer

(

YY_BUFFER_STATE

b

)

Destroy the buffer.

Parameters

b	a buffer created with fortranscannerYY_create_buffer()

Definition at line 58943 of file fortranscanner.cpp.

{
    
        if ( ! b )
                return;

        if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
                YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;

        if ( b->yy_is_our_buffer )
                fortranscannerYYfree((void *) b->yy_ch_buf  );

        fortranscannerYYfree((void *) b  );
}

void fortranscannerYY_flush_buffer

(

YY_BUFFER_STATE

b

)

Discard all buffered characters. On the next scan, YY_INPUT will be called.

Parameters

b	the buffer state to be flushed, usually YY_CURRENT_BUFFER.

Definition at line 58990 of file fortranscanner.cpp.

{
        if ( ! b )
                return;

        b->yy_n_chars = 0;

        /* We always need two end-of-buffer characters.  The first causes
         * a transition to the end-of-buffer state.  The second causes
         * a jam in that state.
         */
        b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
        b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;

        b->yy_buf_pos = &b->yy_ch_buf[0];

        b->yy_at_bol = 1;
        b->yy_buffer_status = YY_BUFFER_NEW;

        if ( b == YY_CURRENT_BUFFER )
                fortranscannerYY_load_buffer_state( );
}

static void fortranscannerYY_init_buffer ( YY_BUFFER_STATE  b, FILE *  file  )

static

Definition at line 58962 of file fortranscanner.cpp.

{
        int oerrno = errno;
    
        fortranscannerYY_flush_buffer(b );

        b->yy_input_file = file;
        b->yy_fill_buffer = 1;

    /* If b is the current buffer, then fortranscannerYY_init_buffer was _probably_
     * called from fortranscannerYYrestart() or through yy_get_next_buffer.
     * In that case, we don't want to reset the lineno or column.
     */
    if (b != YY_CURRENT_BUFFER){
        b->yy_bs_lineno = 1;
        b->yy_bs_column = 0;
    }

        b->yy_is_interactive = 0;
    
        errno = oerrno;
}

static void fortranscannerYY_load_buffer_state ( void  )

static

Definition at line 58901 of file fortranscanner.cpp.

{
        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
        (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
        fortranscannerYYin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
        (yy_hold_char) = *(yy_c_buf_p);
}

YY_BUFFER_STATE fortranscannerYY_scan_buffer	(	char *	base,
		yy_size_t	size
	)

Setup the input buffer state to scan directly from a user-specified character buffer.

Parameters

base	the character buffer
size	the size in bytes of the character buffer

Returns

the newly allocated buffer state object.

Definition at line 59117 of file fortranscanner.cpp.

{
        YY_BUFFER_STATE b;
    
        if ( size < 2 ||
             base[size-2] != YY_END_OF_BUFFER_CHAR ||
             base[size-1] != YY_END_OF_BUFFER_CHAR )
                /* They forgot to leave room for the EOB's. */
                return 0;

        b = (YY_BUFFER_STATE) fortranscannerYYalloc(sizeof( struct yy_buffer_state )  );
        if ( ! b )
                YY_FATAL_ERROR( "out of dynamic memory in fortranscannerYY_scan_buffer()" );

        b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
        b->yy_buf_pos = b->yy_ch_buf = base;
        b->yy_is_our_buffer = 0;
        b->yy_input_file = 0;
        b->yy_n_chars = b->yy_buf_size;
        b->yy_is_interactive = 0;
        b->yy_at_bol = 1;
        b->yy_fill_buffer = 0;
        b->yy_buffer_status = YY_BUFFER_NEW;

        fortranscannerYY_switch_to_buffer(b  );

        return b;
}

YY_BUFFER_STATE fortranscannerYY_scan_bytes	(	yyconst char *	yybytes,
		int	_yybytes_len
	)

Setup the input buffer state to scan the given bytes. The next call to fortranscannerYYlex() will scan from a copy of bytes.

Parameters

bytes	the byte buffer to scan
len	the number of bytes in the buffer pointed to by bytes.

Returns

the newly allocated buffer state object.

Definition at line 59167 of file fortranscanner.cpp.

{
        YY_BUFFER_STATE b;
        char *buf;
        yy_size_t n;
        int i;
    
        /* Get memory for full buffer, including space for trailing EOB's. */
        n = _yybytes_len + 2;
        buf = (char *) fortranscannerYYalloc(n  );
        if ( ! buf )
                YY_FATAL_ERROR( "out of dynamic memory in fortranscannerYY_scan_bytes()" );

        for ( i = 0; i < _yybytes_len; ++i )
                buf[i] = yybytes[i];

        buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;

        b = fortranscannerYY_scan_buffer(buf,n );
        if ( ! b )
                YY_FATAL_ERROR( "bad buffer in fortranscannerYY_scan_bytes()" );

        /* It's okay to grow etc. this buffer, and we should throw it
         * away when we're done.
         */
        b->yy_is_our_buffer = 1;

        return b;
}

YY_BUFFER_STATE fortranscannerYY_scan_string

(

yyconst char *

yystr

)

Setup the input buffer state to scan a string. The next call to fortranscannerYYlex() will scan from a copy of str.

Parameters

yystr

a NUL-terminated string to scan

Returns

the newly allocated buffer state object.

Note

If you want to scan bytes that may contain NUL values, then use fortranscannerYY_scan_bytes() instead.

Definition at line 59154 of file fortranscanner.cpp.

{
    
        return fortranscannerYY_scan_bytes(yystr,strlen(yystr) );
}

void fortranscannerYY_switch_to_buffer

(

YY_BUFFER_STATE

new_buffer

)

Switch to a different input buffer.

Parameters

new_buffer

The new input buffer.

Definition at line 58870 of file fortranscanner.cpp.

{
    
        /* TODO. We should be able to replace this entire function body
         * with
         *              fortranscannerYYpop_buffer_state();
         *              fortranscannerYYpush_buffer_state(new_buffer);
     */
        fortranscannerYYensure_buffer_stack ();
        if ( YY_CURRENT_BUFFER == new_buffer )
                return;

        if ( YY_CURRENT_BUFFER )
                {
                /* Flush out information for old buffer. */
                *(yy_c_buf_p) = (yy_hold_char);
                YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
                }

        YY_CURRENT_BUFFER_LVALUE = new_buffer;
        fortranscannerYY_load_buffer_state( );

        /* We don't actually know whether we did this switch during
         * EOF (fortranscannerYYwrap()) processing, but the only time this flag
         * is looked at is after fortranscannerYYwrap() is called, so it's safe
         * to go ahead and always set it.
         */
        (yy_did_buffer_switch_on_eof) = 1;
}

void * fortranscannerYYalloc

(

yy_size_t

size

)

Definition at line 59431 of file fortranscanner.cpp.

{
        return (void *) malloc( size );
}

static void fortranscannerYYensure_buffer_stack ( void  )

static

Definition at line 59068 of file fortranscanner.cpp.

{
        int num_to_alloc;
    
        if (!(yy_buffer_stack)) {

                /* First allocation is just for 2 elements, since we don't know if this
                 * scanner will even need a stack. We use 2 instead of 1 to avoid an
                 * immediate realloc on the next call.
         */
                num_to_alloc = 1;
                (yy_buffer_stack) = (struct yy_buffer_state**)fortranscannerYYalloc
                                                                (num_to_alloc * sizeof(struct yy_buffer_state*)
                                                                );
                if ( ! (yy_buffer_stack) )
                        YY_FATAL_ERROR( "out of dynamic memory in fortranscannerYYensure_buffer_stack()" );
                                                                  
                memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
                                
                (yy_buffer_stack_max) = num_to_alloc;
                (yy_buffer_stack_top) = 0;
                return;
        }

        if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){

                /* Increase the buffer to prepare for a possible push. */
                int grow_size = 8 /* arbitrary grow size */;

                num_to_alloc = (yy_buffer_stack_max) + grow_size;
                (yy_buffer_stack) = (struct yy_buffer_state**)fortranscannerYYrealloc
                                                                ((yy_buffer_stack),
                                                                num_to_alloc * sizeof(struct yy_buffer_state*)
                                                                );
                if ( ! (yy_buffer_stack) )
                        YY_FATAL_ERROR( "out of dynamic memory in fortranscannerYYensure_buffer_stack()" );

                /* zero only the new slots.*/
                memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
                (yy_buffer_stack_max) = num_to_alloc;
        }
}

void fortranscannerYYfree

(

void *

ptr

)

Definition at line 59448 of file fortranscanner.cpp.

{
        free( (char *) ptr );   /* see fortranscannerYYrealloc() for (char *) cast */
}

int fortranscannerYYget_debug

(

void

)

Definition at line 59331 of file fortranscanner.cpp.

{
        return fortranscannerYY_flex_debug;
}

YY_EXTRA_TYPE fortranscannerYYget_extra

(

void

)

FILE * fortranscannerYYget_in

(

void

)

Get the input stream.

Definition at line 59275 of file fortranscanner.cpp.

{
        return fortranscannerYYin;
}

int fortranscannerYYget_leng

(

void

)

Get the length of the current token.

Definition at line 59291 of file fortranscanner.cpp.

{
        return fortranscannerYYleng;
}

int fortranscannerYYget_lineno

(

void

)

Get the current line number.

Definition at line 59266 of file fortranscanner.cpp.

{
        
    return fortranscannerYYlineno;
}

FILE * fortranscannerYYget_out

(

void

)

Get the output stream.

Definition at line 59283 of file fortranscanner.cpp.

{
        return fortranscannerYYout;
}

char * fortranscannerYYget_text

(

void

)

Get the current token.

Definition at line 59300 of file fortranscanner.cpp.

{
        return fortranscannerYYtext;
}

int fortranscannerYYlex

(

void

)

int fortranscannerYYlex_destroy

(

void

)

Definition at line 59379 of file fortranscanner.cpp.

{
    
    /* Pop the buffer stack, destroying each element. */
        while(YY_CURRENT_BUFFER){
                fortranscannerYY_delete_buffer(YY_CURRENT_BUFFER  );
                YY_CURRENT_BUFFER_LVALUE = NULL;
                fortranscannerYYpop_buffer_state();
        }

        /* Destroy the stack itself. */
        fortranscannerYYfree((yy_buffer_stack) );
        (yy_buffer_stack) = NULL;

    /* Destroy the start condition stack. */
        fortranscannerYYfree((yy_start_stack)  );
        (yy_start_stack) = NULL;

    fortranscannerYYfree ( (yy_state_buf) );
    (yy_state_buf)  = NULL;

    /* Reset the globals. This is important in a non-reentrant scanner so the next time
     * fortranscannerYYlex() is called, initialization will occur. */
    yy_init_globals( );

    return 0;
}

void fortranscannerYYpop_buffer_state

(

void

)

Removes and deletes the top of the stack, if present. The next element becomes the new top.

Definition at line 59049 of file fortranscanner.cpp.

{
        if (!YY_CURRENT_BUFFER)
                return;

        fortranscannerYY_delete_buffer(YY_CURRENT_BUFFER );
        YY_CURRENT_BUFFER_LVALUE = NULL;
        if ((yy_buffer_stack_top) > 0)
                --(yy_buffer_stack_top);

        if (YY_CURRENT_BUFFER) {
                fortranscannerYY_load_buffer_state( );
                (yy_did_buffer_switch_on_eof) = 1;
        }
}

void fortranscannerYYpush_buffer_state

(

YY_BUFFER_STATE

new_buffer

)

Pushes the new state onto the stack. The new state becomes the current state. This function will allocate the stack if necessary.

Parameters

new_buffer

The new state.

Definition at line 59019 of file fortranscanner.cpp.

{
        if (new_buffer == NULL)
                return;

        fortranscannerYYensure_buffer_stack();

        /* This block is copied from fortranscannerYY_switch_to_buffer. */
        if ( YY_CURRENT_BUFFER )
                {
                /* Flush out information for old buffer. */
                *(yy_c_buf_p) = (yy_hold_char);
                YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
                }

        /* Only push if top exists. Otherwise, replace top. */
        if (YY_CURRENT_BUFFER)
                (yy_buffer_stack_top)++;
        YY_CURRENT_BUFFER_LVALUE = new_buffer;

        /* copied from fortranscannerYY_switch_to_buffer. */
        fortranscannerYY_load_buffer_state( );
        (yy_did_buffer_switch_on_eof) = 1;
}

void * fortranscannerYYrealloc	(	void *	ptr,
		yy_size_t	size
	)

Definition at line 59436 of file fortranscanner.cpp.

{
        /* The cast to (char *) in the following accommodates both
         * implementations that use char* generic pointers, and those
         * that use void* generic pointers.  It works with the latter
         * because both ANSI C and C++ allow castless assignment from
         * any pointer type to void*, and deal with argument conversions
         * as though doing an assignment.
         */
        return (void *) realloc( (char *) ptr, size );
}

void fortranscannerYYrestart

(

FILE *

input_file

)

Immediately switch to a different input stream.

Parameters

input_file

A readable stream.

Note

This function does not reset the start condition to INITIAL .

Definition at line 58853 of file fortranscanner.cpp.

{
    
        if ( ! YY_CURRENT_BUFFER ){
        fortranscannerYYensure_buffer_stack ();
                YY_CURRENT_BUFFER_LVALUE =
            fortranscannerYY_create_buffer(fortranscannerYYin,YY_BUF_SIZE );
        }

        fortranscannerYY_init_buffer(YY_CURRENT_BUFFER,input_file );
        fortranscannerYY_load_buffer_state( );
}

void fortranscannerYYset_debug

(

int

debug_flag

)

Definition at line 59336 of file fortranscanner.cpp.

{
        fortranscannerYY_flex_debug = bdebug ;
}

void fortranscannerYYset_extra

(

YY_EXTRA_TYPE

user_defined

)

void fortranscannerYYset_in

(

FILE *

in_str

)

Set the input stream. This does not discard the current input buffer.

Parameters

in_str

A readable stream.

See also

fortranscannerYY_switch_to_buffer

Definition at line 59321 of file fortranscanner.cpp.

{
        fortranscannerYYin = in_str ;
}

void fortranscannerYYset_lineno

(

int

line_number

)

Set the current line number.

Parameters

line_number

Definition at line 59309 of file fortranscanner.cpp.

{
    
    fortranscannerYYlineno = line_number;
}

void fortranscannerYYset_out

(

FILE *

out_str

)

Definition at line 59326 of file fortranscanner.cpp.

{
        fortranscannerYYout = out_str ;
}

static int getAmpersandAtTheStart ( const char *  buf, int  length  )

static

Definition at line 59513 of file fortranscanner.cpp.

{
  for(int i=0; i<length; i++) {
    switch(buf[i]) {
      case ' ':
      case '\t':
        break;
      case '&':
        return i;
      default:
        return -1;
    }
  }
  return -1;
}

static int getAmpOrExclAtTheEnd ( const char *  buf, int  length  )

static

Definition at line 59530 of file fortranscanner.cpp.

{
  // Avoid ampersands in string and comments
  int parseState = Start;
  char quoteSymbol = 0;
  int ampIndex = -1;
  int commentIndex = -1;

  for(int i=0; i<length && parseState!=Comment; i++)
  {
    // When in string, skip backslashes
    // Legacy code, not sure whether this is correct?
    if(parseState==String)
    {
      if(buf[i]=='\\') i++;
    }

    switch(buf[i])
    {
        case '\'':
        case '"':
          // Close string, if quote symbol matches.
          // Quote symbol is set iff parseState==String
          if(buf[i]==quoteSymbol)
          {
             parseState = Start;
             quoteSymbol = 0;
          }
          // Start new string, if not already in string or comment
          else if(parseState==Start)
          {
            parseState = String;
            quoteSymbol = buf[i];
          }
          ampIndex = -1; // invalidate prev ampersand
          break;
        case '!':
          // When in string or comment, ignore exclamation mark
          if(parseState==Start)
          {
            parseState = Comment;
            commentIndex = i;
          }
          break;
        case ' ':  // ignore whitespace
        case '\t':
        case '\n': // this may be at the end of line
          break;
        case '&':
          ampIndex = i;
          break;
        default:
          ampIndex = -1; // invalidate prev ampersand
    }
  }

  if (ampIndex>=0)
    return ampIndex;
  else
   return commentIndex;
}

static Argument * getParameter ( const QCString &  name )

static

Get the argument name.

Definition at line 60467 of file fortranscanner.cpp.

{
  // std::cout<<"addFortranParameter(): "<<name<<" DOCS:"<<(docs.isNull()?QCString("null"):docs)<<std::endl;
  Argument *ret = 0;
  if (current_root->argList==0) return 0;
  ArgumentListIterator ali(*current_root->argList);
  Argument *a;
  for (ali.toFirst();(a=ali.current());++ali)
  {
    if (a->name.lower()==name.lower())
    {
      ret=a;
      //printf("parameter found: %s\n",(const char*)name);
      break;
    }
  } // for
  return ret;
}

static void handleCommentBlock ( const QCString &  doc, bool  brief  )

static

Definition at line 60503 of file fortranscanner.cpp.

{
  bool needsEntry = FALSE;
  static bool hideInBodyDocs = Config_getBool("HIDE_IN_BODY_DOCS");
  int position=0;
  if (docBlockInBody && hideInBodyDocs)
  {
    docBlockInBody = FALSE;
    return;
  }
  DBG_CTX((stderr,"call parseCommentBlock [%s]\n",doc.data()));
  int lineNr = brief ? current->briefLine : current->docLine;
  while (parseCommentBlock(
        g_thisParser,
        docBlockInBody ? subrCurrent.getFirst() : current,
        doc,        // text
        yyFileName, // file
        lineNr,
        docBlockInBody ? FALSE : brief, 
        docBlockInBody ? FALSE : docBlockJavaStyle,
        docBlockInBody,
        defaultProtection,
        position,
        needsEntry
        )) 
  {
           DBG_CTX((stderr,"parseCommentBlock position=%d [%s]  needsEntry=%d\n",position,doc.data()+position,needsEntry));
   if (needsEntry) addCurrentEntry(0);
  }
  DBG_CTX((stderr,"parseCommentBlock position=%d [%s]  needsEntry=%d\n",position,doc.data()+position,needsEntry));

  if (needsEntry) addCurrentEntry(0);
  docBlockInBody = FALSE;
}

if

(

!

yy_init

)

Definition at line 56945 of file fortranscanner.cpp.

                {
                (yy_init) = 1;

#ifdef YY_USER_INIT
                YY_USER_INIT;
#endif

        /* Create the reject buffer large enough to save one state per allowed character. */
        if ( ! (yy_state_buf) )
            (yy_state_buf) = (yy_state_type *)fortranscannerYYalloc(YY_STATE_BUF_SIZE  );
            if ( ! (yy_state_buf) )
                YY_FATAL_ERROR( "out of dynamic memory in fortranscannerYYlex()" );

                if ( ! (yy_start) )
                        (yy_start) = 1; /* first start state */

                if ( ! fortranscannerYYin )
                        fortranscannerYYin = stdin;

                if ( ! fortranscannerYYout )
                        fortranscannerYYout = stdout;

                if ( ! YY_CURRENT_BUFFER ) {
                        fortranscannerYYensure_buffer_stack ();
                        YY_CURRENT_BUFFER_LVALUE =
                                fortranscannerYY_create_buffer(fortranscannerYYin,YY_BUF_SIZE );
                }

                fortranscannerYY_load_buffer_state( );
                }

static void initEntry ( )

static

Definition at line 60336 of file fortranscanner.cpp.

{
  if (typeMode)
  {
    current->protection = typeProtection;
  }
  else
  {
    current->protection = defaultProtection;
  }
  current->mtype      = mtype;
  current->virt       = virt;
  current->stat       = gstat;
  current->lang       = SrcLangExt_Fortran; 
  initGroupInfo(current);
}

static void initParser ( )

static

Definition at line 60331 of file fortranscanner.cpp.

{
  last_entry = 0;
}

static void insertCharacter ( char *  contents, int  length, int  pos, char  c  )

static

Definition at line 59652 of file fortranscanner.cpp.

{
  // shift tail by one character
  for(int i=length; i>pos; i--)
    contents[i]=contents[i-1];
  // set the character
  contents[pos] = c;
}

static CommentInPrepass * locatePrepassComment ( int  from, int  to  )

static

Definition at line 59490 of file fortranscanner.cpp.

                                                                {
  //printf("Locate %d-%d\n", from, to);
  for(uint i=0; i<comments.count(); i++) { // todo: optimize
    int c = comments.at(i)->column;
    //printf("Candidate %d\n", c);
    if (c>=from && c<=to) {
      // comment for previous variable or parameter
      return comments.at(i);
    }
  }
  return NULL;
}

static int max ( int  a, int  b  )

static

Definition at line 60366 of file fortranscanner.cpp.

{return a>b?a:b;}

static void newLine ( )

static

Definition at line 59483 of file fortranscanner.cpp.

                      {
  yyLineNr++;
  yyLineNr+=lineCountPrepass;
  lineCountPrepass=0;
  comments.clear();
}

static void parseMain ( const char *  fileName, const char *  fileBuf, Entry *  rt, FortranFormat  format  )

static

Definition at line 60702 of file fortranscanner.cpp.

{
  char *tmpBuf = NULL;
  initParser();

  defaultProtection = Public;
  inputString = fileBuf;
  inputPosition = 0;
  inputStringPrepass = NULL;
  inputPositionPrepass = 0;

  //anonCount     = 0;  // don't reset per file
  mtype         = Method;
  gstat         = FALSE;
  virt          = Normal;
  current_root  = rt;
  global_root   = rt;
  inputFile.setName(fileName);
  if (inputFile.open(IO_ReadOnly))
  {
    isFixedForm = recognizeFixedForm(fileBuf,format);

    if (isFixedForm) 
    {
      msg("Prepassing fixed form of %s\n", fileName);
      //printf("---strlen=%d\n", strlen(fileBuf));
      //clock_t start=clock();

      inputString = prepassFixedForm(fileBuf);

      //clock_t end=clock();
      //printf("CPU time used=%f\n", ((double) (end-start))/CLOCKS_PER_SEC);
    }
    else if (inputString[strlen(fileBuf)-1] != '\n')
    {
      tmpBuf = (char *)malloc(strlen(fileBuf)+2);
      strcpy(tmpBuf,fileBuf);
      tmpBuf[strlen(fileBuf)]= '\n';
      tmpBuf[strlen(fileBuf)+1]= '\000';
      inputString = tmpBuf;
    }

    yyLineNr= 1 ; 
    yyFileName = fileName;
    msg("Parsing file %s...\n",yyFileName.data());

    startScope(rt); // implies current_root = rt
    initParser();
    groupEnterFile(yyFileName,yyLineNr);

    current          = new Entry;
    current->lang    = SrcLangExt_Fortran; 
    current->name    = yyFileName;
    current->section = Entry::SOURCE_SEC;
    current_root->addSubEntry(current);
    file_root        = current;
    current          = new Entry;
    current->lang    = SrcLangExt_Fortran; 

    fortranscannerYYrestart( fortranscannerYYin );
    {
      BEGIN( Start );
    }

    fortranscannerYYlex();
    groupLeaveFile(yyFileName,yyLineNr);

    endScope(current_root, TRUE); // TRUE - global root

    //debugCompounds(rt); //debug 

    rt->program.resize(0);
    delete current; current=0;
    moduleProcedures.clear();
    if (tmpBuf) {
      free((char*)tmpBuf);
      inputString=NULL;
    }
    if (isFixedForm) {
      free((char*)inputString);
      inputString=NULL;
    }

    inputFile.close();
  }
}

static void popBuffer ( )

static

Definition at line 59813 of file fortranscanner.cpp.

                        {
  DBG_CTX((stderr, "--POP--"));
  include_stack_ptr --;
  fortranscannerYY_delete_buffer(YY_CURRENT_BUFFER );
  fortranscannerYY_switch_to_buffer(include_stack[include_stack_ptr] );
}

static const char* prepassFixedForm ( const char *  contents )

static

Definition at line 59662 of file fortranscanner.cpp.

{
  int column=0;
  int prevLineLength=0;
  int prevLineAmpOrExclIndex=-1;
  bool emptyLabel=TRUE;
  bool commented=FALSE;
  bool inSingle=FALSE;
  bool inDouble=FALSE;
  bool inBackslash=FALSE;
  int newContentsSize = strlen(contents)+3; // \000, \n (when necessary) and one spare character (to avoid reallocation)
  char* newContents = (char*)malloc(newContentsSize);

  for(int i=0, j=0;;i++,j++) {
    if(j>=newContentsSize-3) { // check for spare characters, which may be eventually used below (by & and '! ')
      newContents = (char*)realloc(newContents, newContentsSize+1000);
      newContentsSize = newContentsSize+1000;
    }

    column++;
    char c = contents[i];
    switch(c) {
      case '\n':
        prevLineLength=column;
        prevLineAmpOrExclIndex=getAmpOrExclAtTheEnd(&contents[i-prevLineLength+1], prevLineLength);
        column=0;
        emptyLabel=TRUE;
        commented=FALSE;
        newContents[j]=c;
        break;
      case ' ':
      case '\t':
        newContents[j]=c;
        break;
      case '\000':
        newContents[j]='\000';
        newContentsSize = strlen(newContents);
        if (newContents[newContentsSize - 1] != '\n')
        {
          // to be on the safe side
          newContents = (char*)realloc(newContents, newContentsSize+2);
          newContents[newContentsSize] = '\n';
          newContents[newContentsSize + 1] = '\000';
        }
        return newContents;
      case '"':
      case '\'':
      case '\\':
        if ((column <= fixedCommentAfter) && (column!=6) && !commented)
        {
          // we have some special cases in respect to strings and exscaped string characters
          newContents[j]=c;
          if (c == '\\')
          {
            inBackslash = !inBackslash;
            break;
          }
          else if (c == '\'')
          {
            if (!inDouble) inSingle = !inSingle;
            break;
          }
          else if (c == '"')
          {
            if (!inSingle) inDouble = !inDouble;
            break;
          }
        }
        inBackslash = FALSE;
        // fallthrough
      case 'C':
      case 'c':
      case '*':
      case '!':
        if ((column <= fixedCommentAfter) && (column!=6))
        {
          emptyLabel=FALSE;
          if(column==1)
          {
            newContents[j]='!';
            commented = TRUE;
          }
          else if ((c == '!') && !inDouble && !inSingle)
          {
            newContents[j]=c;
            commented = TRUE;
          }
          else
          {
            newContents[j]=c;
          }
          break;
        }
        // fallthrough
      default:
        if(column==6 && emptyLabel) { // continuation
          if (c != '0') { // 0 not allowed as continuation character, see f95 standard paragraph 3.3.2.3
            newContents[j]=' ';

            if(prevLineAmpOrExclIndex==-1) { // add & just before end of previous line
              insertCharacter(newContents, j+1, (j+1)-6-1, '&');
              j++;
            } else { // add & just before end of previous line comment
              insertCharacter(newContents, j+1, (j+1)-6-prevLineLength+prevLineAmpOrExclIndex, '&');
              j++;
            }
          } else {
            newContents[j]=c; // , just handle like space
          }
        } else if ((column > fixedCommentAfter) && !commented) {
          // first non commented non blank character after position fixedCommentAfter
          if (c != '!') {
            // I'm not a possible start of doxygen comment
            newContents[j++]='!';
            newContents[j++]=' '; // so that '<' and '>' as first character are not converted to doxygen comment
          }
          newContents[j]=c;
          commented = TRUE;
        } else {
          newContents[j]=c;
          emptyLabel=FALSE;
        }
        break;
    }
  }

  newContentsSize = strlen(newContents);
  if (newContents[newContentsSize - 1] != '\n')
  {
    // to be on the safe side
    newContents = (char*)realloc(newContents, newContentsSize+2);
    newContents[newContentsSize] = '\n';
    newContents[newContentsSize + 1] = '\000';
  }
  return newContents;
}

static void pushBuffer ( QCString &  buffer )

static

Definition at line 59799 of file fortranscanner.cpp.

{
  if (include_stack_cnt <= include_stack_ptr)
  {
     include_stack_cnt++;
     include_stack = (YY_BUFFER_STATE *)realloc(include_stack, include_stack_cnt * sizeof(YY_BUFFER_STATE));
  }
  include_stack[include_stack_ptr++] = YY_CURRENT_BUFFER;
  fortranscannerYY_switch_to_buffer(fortranscannerYY_scan_string(buffer));

  DBG_CTX((stderr, "--PUSH--%s", (const char *)buffer));
  buffer = NULL;
}

static bool recognizeFixedForm ( const char *  contents, FortranFormat  format  )

static

Definition at line 59609 of file fortranscanner.cpp.

{
  int column=0;
  bool skipLine=FALSE;

  if (format == FortranFormat_Fixed) return TRUE;
  if (format == FortranFormat_Free)  return FALSE;

  for(int i=0;;i++) {
    column++;

    switch(contents[i]) {
      case '\n':
        column=0;
        skipLine=FALSE;
        break;
      case ' ':
        break;
      case '\000':
        return FALSE;
      case '#':
        skipLine=TRUE;
        break;
      case 'C':
      case 'c':
      case '*':
        if(column==1) return TRUE;
        if(skipLine) break;
        return FALSE;
      case '!':
        if(column>1 && column<7) return FALSE;
        skipLine=TRUE;
        break;
      default:
        if(skipLine) break;
        if(column==7) return TRUE;
        return FALSE;
    }
  }
  return FALSE;
}

void resolveModuleProcedures ( QList< Entry > &  moduleProcedures, Entry *  current_root  )

static

fill empty interface module procedures with info from corresponding module subprogs : handle procedures in used modules

Definition at line 59838 of file fortranscanner.cpp.

{
  if (moduleProcedures.isEmpty()) return;
 
  EntryListIterator eli1(moduleProcedures);
  // for all module procedures
  for (Entry *ce1; (ce1=eli1.current()); ++eli1) 
  {
    // check all entries in this module
    EntryListIterator eli2(*current_root->children());
    for (Entry *ce2; (ce2=eli2.current()); ++eli2) 
    {
      if (ce1->name == ce2->name) 
      {
        copyEntry(ce1, ce2);
      }
    } // for procedures in current module
  } // for all interface module procedures
  moduleProcedures.clear();
}

static void scanner_abort ( )

static

Definition at line 60847 of file fortranscanner.cpp.

{
  fprintf(stderr,"********************************************************************\n");
  fprintf(stderr,"Error in file %s line: %d, state: %d\n",yyFileName.data(),yyLineNr,YY_START);
  fprintf(stderr,"********************************************************************\n");
   
  EntryListIterator eli(*global_root->children());
  Entry *ce;
  bool start=FALSE;

  for (;(ce=eli.current());++eli)
  {
     if (ce == file_root) start=TRUE;
     if (start) ce->reset(); 
  } 

  // dummy call to avoid compiler warning
  (void)yy_top_state();
  
  return;
  //exit(-1);
}

static void startCommentBlock ( bool  brief )

static

Definition at line 60487 of file fortranscanner.cpp.

{
  if (brief)
  {
    current->briefFile = yyFileName;
    current->briefLine = yyLineNr;
  }
  else
  {
    current->docFile = yyFileName;
    current->docLine = yyLineNr;
  }
}

static void startScope ( Entry *  scope )

static

Starts the new scope in fortran program. Consider using this function when starting module, interface, function or other program block.

See also

endScope()

Definition at line 60197 of file fortranscanner.cpp.

{
  //cout<<"start scope: "<<scope->name<<endl;
  current_root= scope; /* start substructure */

  QMap<QCString,SymbolModifiers> mdfMap;
  modifiers.insert(scope, mdfMap);
}

static void subrHandleCommentBlock ( const QCString &  doc, bool  brief  )

static

Handle parameter description as defined after the declaration of the parameter.

Definition at line 60540 of file fortranscanner.cpp.

{
  QCString loc_doc;
  loc_doc = doc.stripWhiteSpace();

  Entry *tmp_entry = current; 
  current = subrCurrent.getFirst(); // temporarily switch to the entry of the subroutine / function

  // Still in the specification section so no inbodyDocs yet, but parameter documentation
  current->inbodyDocs = "";

  // strip \\param or @param, so we can do some extra checking. We will add it later on again.
  if (!loc_doc.stripPrefix("\\param") &&
      !loc_doc.stripPrefix("@param")
     ) (void)loc_doc; // Do nothing work has been done by stripPrefix; (void)loc_doc: to overcome 'empty controlled statement' warning
  loc_doc.stripWhiteSpace();

  // direction as defined with the declaration of the parameter
  int dir1 = modifiers[current_root][argName.lower()].direction;
  // in description [in] is specified
  if (loc_doc.lower().find(directionParam[SymbolModifiers::IN]) == 0)
  {
    // check if with the declaration intent(in) or nothing has been specified
    if ((directionParam[dir1] == directionParam[SymbolModifiers::NONE_D]) ||
        (directionParam[dir1] == directionParam[SymbolModifiers::IN]))
    {
      // strip direction
      loc_doc = loc_doc.right(loc_doc.length()-strlen(directionParam[SymbolModifiers::IN]));
      loc_doc.stripWhiteSpace();
      // in case of emty documentation or (now) just name, consider it as no documemntation
      if (loc_doc.isEmpty() || (loc_doc.lower() == argName.lower()))
      {
        // reset current back to the part inside the routine
        current=tmp_entry;
        return;
      }
      handleCommentBlock(QCString("\n\n@param ") + directionParam[SymbolModifiers::IN] + " " + 
                         argName + " " + loc_doc,brief);
    }
    else
    {
      // something different specified, give warning and leave error.
      warn(yyFileName,yyLineNr, "Routine: " + current->name + current->args +
           " inconsistency between intent attribute and documentation for parameter: " + argName);
      handleCommentBlock(QCString("\n\n@param ") + directionParam[dir1] + " " + 
                         argName + " " + loc_doc,brief);
    }
  }
  // analogous to the [in] case, here [out] direction specified
  else if (loc_doc.lower().find(directionParam[SymbolModifiers::OUT]) == 0)
  {
    if ((directionParam[dir1] == directionParam[SymbolModifiers::NONE_D]) ||
        (directionParam[dir1] == directionParam[SymbolModifiers::OUT]))
    {
      loc_doc = loc_doc.right(loc_doc.length()-strlen(directionParam[SymbolModifiers::OUT]));
      loc_doc.stripWhiteSpace();
      if (loc_doc.isEmpty() || (loc_doc.lower() == argName.lower()))
      {
        current=tmp_entry;
        return;
      }
      handleCommentBlock(QCString("\n\n@param ") + directionParam[SymbolModifiers::OUT] + " " + 
                         argName + " " + loc_doc,brief);
    }
    else
    {
      warn(yyFileName,yyLineNr, "Routine: " + current->name + current->args +
           " inconsistency between intent attribute and documentation for parameter: " + argName);
      handleCommentBlock(QCString("\n\n@param ") + directionParam[dir1] + " " + 
                         argName + " " + loc_doc,brief);
    }
  }
  // analogous to the [in] case, here [in,out] direction specified
  else if (loc_doc.lower().find(directionParam[SymbolModifiers::INOUT]) == 0)
  {
    if ((directionParam[dir1] == directionParam[SymbolModifiers::NONE_D]) ||
        (directionParam[dir1] == directionParam[SymbolModifiers::INOUT]))
    {
      loc_doc = loc_doc.right(loc_doc.length()-strlen(directionParam[SymbolModifiers::INOUT]));
      loc_doc.stripWhiteSpace();
      if (loc_doc.isEmpty() || (loc_doc.lower() == argName.lower()))
      {
        current=tmp_entry;
        return;
      }
      handleCommentBlock(QCString("\n\n@param ") + directionParam[SymbolModifiers::INOUT] + " " + 
                         argName + " " + loc_doc,brief);
    }
    else
    {
      warn(yyFileName,yyLineNr, "Routine: " + current->name + current->args +
           " inconsistency between intent attribute and documentation for parameter: " + argName);
      handleCommentBlock(QCString("\n\n@param ") + directionParam[dir1] + " " + 
                         argName + " " + loc_doc,brief);
    }
  }
  // analogous to the [in] case; here no direction specified
  else
  {
    if (loc_doc.isEmpty() || (loc_doc.lower() == argName.lower()))
    {
      current=tmp_entry;
      return;
    }
    handleCommentBlock(QCString("\n\n@param ") + directionParam[dir1] + " " + 
                       argName + " " + loc_doc,brief);
  }

  // reset current back to the part inside the routine
  current=tmp_entry;
}

static void subrHandleCommentBlockResult ( const QCString &  doc, bool  brief  )

static

Handle result description as defined after the declaration of the parameter.

Definition at line 60653 of file fortranscanner.cpp.

{
  QCString loc_doc;
  loc_doc = doc.stripWhiteSpace();

  Entry *tmp_entry = current; 
  current = subrCurrent.getFirst(); // temporarily switch to the entry of the subroutine / function

  // Still in the specification section so no inbodyDocs yet, but parameter documentation
  current->inbodyDocs = "";

  // strip \\returns or @returns. We will add it later on again.
  if (!loc_doc.stripPrefix("\\returns") &&
      !loc_doc.stripPrefix("\\return") &&
      !loc_doc.stripPrefix("@returns") &&
      !loc_doc.stripPrefix("@return")
     ) (void)loc_doc; // Do nothing work has been done by stripPrefix; (void)loc_doc: to overcome 'empty controlled statement' warning
  loc_doc.stripWhiteSpace();

  if (loc_doc.isEmpty() || (loc_doc.lower() == argName.lower()))
  {
    current=tmp_entry;
    return;
  }
  handleCommentBlock(QCString("\n\n@returns ") + loc_doc,brief);

  // reset current back to the part inside the routine
  current=tmp_entry;
}

void truncatePrepass ( int  index )

static

Definition at line 59595 of file fortranscanner.cpp.

{
  int length = inputStringPrepass.length();
  for (int i=index+1; i<length; i++) {
    if (inputStringPrepass[i]=='!' && i<length-1 && inputStringPrepass[i+1]=='<') { // save comment 
      struct CommentInPrepass *c=new CommentInPrepass(index, inputStringPrepass.right(length-i-2));
      comments.append(c);
    }
  }
  inputStringPrepass.truncate(index);
}

static void updateVariablePrepassComment ( int  from, int  to  )

static

Definition at line 59503 of file fortranscanner.cpp.

                                                           {
  CommentInPrepass *c = locatePrepassComment(from, to);
  if (c!=NULL && v_type == V_VARIABLE) {
    last_entry->brief = c->str;
  } else if (c!=NULL && v_type == V_PARAMETER) {
    Argument *parameter = getParameter(argName);
    if (parameter) parameter->docs = c->str;
  }
}

while

(

1

)

Definition at line 56977 of file fortranscanner.cpp.

                {
                yy_cp = (yy_c_buf_p);

                /* Support of fortranscannerYYtext. */
                *yy_cp = (yy_hold_char);

                /* yy_bp points to the position in yy_ch_buf of the start of
                 * the current run.
                 */
                yy_bp = yy_cp;

                yy_current_state = (yy_start);
                yy_current_state += YY_AT_BOL();

                (yy_state_ptr) = (yy_state_buf);
                *(yy_state_ptr)++ = yy_current_state;

yy_match:
                do
                        {
                        register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
                        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                                {
                                yy_current_state = (int) yy_def[yy_current_state];
                                if ( yy_current_state >= 24248 )
                                        yy_c = yy_meta[(unsigned int) yy_c];
                                }
                        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
                        *(yy_state_ptr)++ = yy_current_state;
                        ++yy_cp;
                        }
                while ( yy_current_state != 24247 );

yy_find_action:
                yy_current_state = *--(yy_state_ptr);
                (yy_lp) = yy_accept[yy_current_state];
find_rule: /* we branch to this label when backing up */
                for ( ; ; ) /* until we find what rule we matched */
                        {
                        if ( (yy_lp) && (yy_lp) < yy_accept[yy_current_state + 1] )
                                {
                                yy_act = yy_acclist[(yy_lp)];
                                if ( yy_act & YY_TRAILING_HEAD_MASK ||
                                     (yy_looking_for_trail_begin) )
                                        {
                                        if ( yy_act == (yy_looking_for_trail_begin) )
                                                {
                                                (yy_looking_for_trail_begin) = 0;
                                                yy_act &= ~YY_TRAILING_HEAD_MASK;
                                                break;
                                                }
                                        }
                                else if ( yy_act & YY_TRAILING_MASK )
                                        {
                                        (yy_looking_for_trail_begin) = yy_act & ~YY_TRAILING_MASK;
                                        (yy_looking_for_trail_begin) |= YY_TRAILING_HEAD_MASK;
                                        (yy_full_match) = yy_cp;
                                        (yy_full_state) = (yy_state_ptr);
                                        (yy_full_lp) = (yy_lp);
                                        }
                                else
                                        {
                                        (yy_full_match) = yy_cp;
                                        (yy_full_state) = (yy_state_ptr);
                                        (yy_full_lp) = (yy_lp);
                                        break;
                                        }
                                ++(yy_lp);
                                goto find_rule;
                                }
                        --yy_cp;
                        yy_current_state = *--(yy_state_ptr);
                        (yy_lp) = yy_accept[yy_current_state];
                        }

                YY_DO_BEFORE_ACTION;

do_action:      /* This label is used only to access EOF actions. */

                switch ( yy_act )
        { /* beginning of action switch */
case 1:
/* rule 1 can match eol */
YY_RULE_SETUP
#line 325 "fortranscanner.l"
{ // prepass: look for line continuations
                                          functionLine = FALSE;

                                          DBG_CTX((stderr, "---%s", fortranscannerYYtext));

                                            int indexStart = getAmpersandAtTheStart(fortranscannerYYtext, (int)fortranscannerYYleng);
                                            int indexEnd = getAmpOrExclAtTheEnd(fortranscannerYYtext, (int)fortranscannerYYleng);
                                            if (indexEnd>=0 && fortranscannerYYtext[indexEnd]!='&') //we are only interested in amp
                                              indexEnd=-1;

                                            if(indexEnd<0){ // ----- no ampersand as line continuation
                                               if(YY_START == Prepass) { // last line in "continuation"

                                                 // Only take input after initial ampersand
                                                 inputStringPrepass+=(const char*)(fortranscannerYYtext+(indexStart+1));
   
                                                 //printf("BUFFER:%s\n", (const char*)inputStringPrepass);
                                                 pushBuffer(inputStringPrepass);
                                                 yyColNr = 0;                                            
                                                 yy_pop_state();
                                               } else { // simple line
                                                 yyColNr = 0;
                                                 REJECT;
                                               }

                                            } else { // ----- line with continuation
                                              if(YY_START != Prepass) {
                                                comments.setAutoDelete(TRUE);
                                                comments.clear();
                                                yy_push_state(Prepass);
                                              }

                                              int length = inputStringPrepass.length();

                                              // Only take input after initial ampersand
                                              inputStringPrepass+=(const char*)(fortranscannerYYtext+(indexStart+1));
                                              lineCountPrepass ++;

                                              // cut off & and remove following comment if present
                                              truncatePrepass(length+indexEnd-(indexStart+1));
                                            }

                                        }
        YY_BREAK
/*------ ignore strings that are not initialization strings */ 
case 2:
YY_RULE_SETUP
#line 371 "fortranscanner.l"
{ if (yy_top_state() == Initialization
                                              || yy_top_state() == ArrayInitializer)
                                            initializer+=fortranscannerYYtext;
                                        }
        YY_BREAK
case 3:
YY_RULE_SETUP
#line 375 "fortranscanner.l"
{ if (yy_top_state() == Initialization
                                              || yy_top_state() == ArrayInitializer)
                                            initializer+=fortranscannerYYtext;
                                        }
        YY_BREAK
case 4:
YY_RULE_SETUP
#line 379 "fortranscanner.l"
{ // string ends with next quote without previous backspace
                                          if (fortranscannerYYtext[0]!=stringStartSymbol) { yyColNr -= (int)fortranscannerYYleng; REJECT; } // single vs double quote
                                          if (yy_top_state() == Initialization
                                              || yy_top_state() == ArrayInitializer)
                                            initializer+=fortranscannerYYtext;
                                          yy_pop_state();
                                        }           
        YY_BREAK
case 5:
YY_RULE_SETUP
#line 386 "fortranscanner.l"
{ if (yy_top_state() == Initialization
                                              || yy_top_state() == ArrayInitializer)
                                            initializer+=fortranscannerYYtext;
                                        } 
        YY_BREAK
case 6:
YY_RULE_SETUP
#line 390 "fortranscanner.l"
{ /* string starts */
                                          if (YY_START == StrIgnore) { yyColNr -= (int)fortranscannerYYleng; REJECT; }; // ignore in simple comments
                                          yy_push_state(YY_START);
                                          if (yy_top_state() == Initialization
                                              || yy_top_state() == ArrayInitializer)
                                            initializer+=fortranscannerYYtext;
                                          stringStartSymbol=fortranscannerYYtext[0]; // single or double quote
                                          BEGIN(String);
                                        }
        YY_BREAK
/*------ ignore simple comment (not documentation comments) */
case 7:
*yy_cp = (yy_hold_char); /* undo effects of setting up fortranscannerYYtext */
(yy_c_buf_p) = yy_cp = yy_bp + 1;
YY_DO_BEFORE_ACTION; /* set up fortranscannerYYtext again */
YY_RULE_SETUP
#line 402 "fortranscanner.l"
{  if (YY_START == String) { yyColNr -= (int)fortranscannerYYleng; REJECT; } // "!" is ignored in strings
                                          // skip comment line (without docu comments "!>" "!<" ) 
                                          /* ignore further "!" and ignore comments in Strings */
                                          if ((YY_START != StrIgnore) && (YY_START != String)) 
                                          {
                                            yy_push_state(YY_START);
                                            BEGIN(StrIgnore); 
                                            debugStr="*!";
                                            DBG_CTX((stderr,"start comment %d\n",yyLineNr));
                                           }      
                                        }
        YY_BREAK
case 8:
/* rule 8 can match eol */
*yy_cp = (yy_hold_char); /* undo effects of setting up fortranscannerYYtext */
(yy_c_buf_p) = yy_cp -= 1;
YY_DO_BEFORE_ACTION; /* set up fortranscannerYYtext again */
YY_RULE_SETUP
#line 413 "fortranscanner.l"
{ yy_pop_state(); // comment ends with endline character
                                          DBG_CTX((stderr,"end comment %d %s\n",yyLineNr,debugStr.data()));
                                        } // comment line ends
        YY_BREAK
case 9:
YY_RULE_SETUP
#line 416 "fortranscanner.l"
{ debugStr+=fortranscannerYYtext; } 
        YY_BREAK
/*------ use handling ------------------------------------------------------------*/
case 10:
YY_RULE_SETUP
#line 421 "fortranscanner.l"
{
                                          if(YY_START == Start)
                                          {
                                            addModule(NULL); 
                                            yy_push_state(ModuleBody); //anon program
                                          }
                                          yy_push_state(Use);
                                        }
        YY_BREAK
case 11:
YY_RULE_SETUP
#line 429 "fortranscanner.l"
{ 
                                          DBG_CTX((stderr,"using dir %s\n",fortranscannerYYtext));
                                          current->name=fortranscannerYYtext;
                                          current->fileName = yyFileName; 
                                          current->section=Entry::USINGDIR_SEC;
                                          current_root->addSubEntry(current);
                                          current = new Entry;
                                          current->lang = SrcLangExt_Fortran; 
                                          yy_pop_state();
                                        }
        YY_BREAK
case 12:
*yy_cp = (yy_hold_char); /* undo effects of setting up fortranscannerYYtext */
(yy_c_buf_p) = yy_cp -= 1;
YY_DO_BEFORE_ACTION; /* set up fortranscannerYYtext again */
YY_RULE_SETUP
#line 439 "fortranscanner.l"
{ 
                                          useModuleName=fortranscannerYYtext;
                                        }
        YY_BREAK
case 13:
YY_RULE_SETUP
#line 442 "fortranscanner.l"
{ BEGIN(UseOnly); 
                                        }           
        YY_BREAK
case 14:
YY_RULE_SETUP
#line 444 "fortranscanner.l"
{}
        YY_BREAK
case 15:
YY_RULE_SETUP
#line 445 "fortranscanner.l"
{
                                          current->name= useModuleName+"::"+fortranscannerYYtext;
                                          current->fileName = yyFileName; 
                                          current->section=Entry::USINGDECL_SEC;
                                          current_root->addSubEntry(current);
                                          current = new Entry ;
                                          current->lang = SrcLangExt_Fortran; 
                                        }
        YY_BREAK
case 16:
/* rule 16 can match eol */
YY_RULE_SETUP
#line 453 "fortranscanner.l"
{
                                          yyColNr -= 1;
                                          unput(*fortranscannerYYtext);
                                          yy_pop_state();
                                        }
        YY_BREAK
/* INTERFACE definitions */

case 17:
YY_RULE_SETUP
#line 461 "fortranscanner.l"
{ /* variable with interface prefix */ }
        YY_BREAK
case 18:
YY_RULE_SETUP
#line 462 "fortranscanner.l"
{ ifType = IF_SPECIFIC;
                                          yy_push_state(InterfaceBody);
                                          // do not start a scope here, every
                                          // interface body is a scope of its own
                                        }
        YY_BREAK
case 19:
YY_RULE_SETUP
#line 468 "fortranscanner.l"
{ ifType = IF_ABSTRACT;
                                          yy_push_state(InterfaceBody);
                                          // do not start a scope here, every
                                          // interface body is a scope of its own
                                        }
        YY_BREAK
case 20:
/* rule 20 can match eol */
YY_RULE_SETUP
#line 474 "fortranscanner.l"
{ ifType = IF_GENERIC;
                                          current->bodyLine = yyLineNr + lineCountPrepass + 1; // we have to be at the line after the definition and we have to take continuation lines into account.
                                          yy_push_state(InterfaceBody);

                                          // extract generic name
                                          QCString name = QCString(fortranscannerYYtext).stripWhiteSpace();
                                          name = name.right(name.length() - 9).stripWhiteSpace().lower();
                                          addInterface(name, ifType);
                                          startScope(last_entry);
                                        }
        YY_BREAK

case 21:
YY_RULE_SETUP
#line 486 "fortranscanner.l"
{
                                          // end scope only if GENERIC interface
                                          if (ifType == IF_GENERIC)last_entry->parent()->endBodyLine = yyLineNr - 1;
                                          if (ifType == IF_GENERIC && !endScope(current_root))
                                            yyterminate();

                                          ifType = IF_NONE;
                                          yy_pop_state();
                                        }
        YY_BREAK
case 22:
YY_RULE_SETUP
#line 495 "fortranscanner.l"
{ yy_push_state(YY_START);
                                          BEGIN(ModuleProcedure);
                                        }
        YY_BREAK
case 23:
YY_RULE_SETUP
#line 498 "fortranscanner.l"
{ if (ifType == IF_ABSTRACT || ifType == IF_SPECIFIC)
                                          {
                                            addInterface(fortranscannerYYtext, ifType);
                                            startScope(last_entry);
                                          }

                                          current->section = Entry::FUNCTION_SEC ;
                                          current->name = fortranscannerYYtext; 
                                          moduleProcedures.append(current);
                                          addCurrentEntry(1);
                                        }
        YY_BREAK
case 24:
/* rule 24 can match eol */
YY_RULE_SETUP
#line 509 "fortranscanner.l"
{ yyColNr -= 1;
                                          unput(*fortranscannerYYtext); 
                                          yy_pop_state();
                                        }
        YY_BREAK
case 25:
YY_RULE_SETUP
#line 513 "fortranscanner.l"
{}
        YY_BREAK
/*-- Contains handling --*/
case 26:
/* rule 26 can match eol */
YY_RULE_SETUP
#line 516 "fortranscanner.l"
{
                                          if(YY_START == Start)
                                          {
                                            addModule(NULL); 
                                            yy_push_state(ModuleBodyContains); //anon program
                                          }                                            
                                        }
        YY_BREAK
case 27:
/* rule 27 can match eol */
YY_RULE_SETUP
#line 523 "fortranscanner.l"
{ BEGIN(ModuleBodyContains); }
        YY_BREAK
case 28:
/* rule 28 can match eol */
YY_RULE_SETUP
#line 524 "fortranscanner.l"
{ BEGIN(SubprogBodyContains); }
        YY_BREAK
case 29:
/* rule 29 can match eol */
YY_RULE_SETUP
#line 525 "fortranscanner.l"
{ BEGIN(TypedefBodyContains); }
        YY_BREAK
/*------ module handling ------------------------------------------------------------*/ 
case 30:
YY_RULE_SETUP
#line 528 "fortranscanner.l"
{  //
                                         v_type = V_IGNORE;
                                            yy_push_state(BlockData);
                                            defaultProtection = Public;
                                       }
        YY_BREAK
case 31:
YY_RULE_SETUP
#line 533 "fortranscanner.l"
{  //
                                         v_type = V_IGNORE;
                                            if(fortranscannerYYtext[0]=='m' || fortranscannerYYtext[0]=='M')
                                              yy_push_state(Module);
                                            else
                                              yy_push_state(Program);
                                            defaultProtection = Public;
                                       }
        YY_BREAK
case 32:
/* rule 32 can match eol */
YY_RULE_SETUP
#line 541 "fortranscanner.l"
{ // end block data
                                            //if (!endScope(current_root))
                                            //  yyterminate();
                                            defaultProtection = Public;
                                            yy_pop_state();
                                       }
        YY_BREAK
case 33:
/* rule 33 can match eol */
YY_RULE_SETUP
#line 547 "fortranscanner.l"
{ // end module 
                                            resolveModuleProcedures(moduleProcedures, current_root);
                                            if (!endScope(current_root))
                                              yyterminate();
                                            defaultProtection = Public;
                                            yy_pop_state();
                                       }
        YY_BREAK
case 34:
YY_RULE_SETUP
#line 554 "fortranscanner.l"
{  
                                            addModule(fortranscannerYYtext, TRUE);
                                            BEGIN(ModuleBody);
                                       }
        YY_BREAK
case 35:
YY_RULE_SETUP
#line 559 "fortranscanner.l"
{  
                                            addModule(fortranscannerYYtext, FALSE);
                                            BEGIN(ModuleBody);
                                       }
        YY_BREAK
/*------- access specification --------------------------------------------------------------------------*/
case 36:
/* rule 36 can match eol */
*yy_cp = (yy_hold_char); /* undo effects of setting up fortranscannerYYtext */
(yy_c_buf_p) = yy_cp = yy_bp + 7;
YY_DO_BEFORE_ACTION; /* set up fortranscannerYYtext again */
YY_RULE_SETUP
#line 566 "fortranscanner.l"
{ defaultProtection = Private;
                                           current->protection = defaultProtection ;
                                         }
        YY_BREAK
case 37:
/* rule 37 can match eol */
*yy_cp = (yy_hold_char); /* undo effects of setting up fortranscannerYYtext */
(yy_c_buf_p) = yy_cp = yy_bp + 6;
YY_DO_BEFORE_ACTION; /* set up fortranscannerYYtext again */
YY_RULE_SETUP
#line 569 "fortranscanner.l"
{ defaultProtection = Public;
                                           current->protection = defaultProtection ;
                                         }
        YY_BREAK
/*------- type definition  -------------------------------------------------------------------------------*/
case 38:
/* rule 38 can match eol */
*yy_cp = (yy_hold_char); /* undo effects of setting up fortranscannerYYtext */
(yy_c_buf_p) = yy_cp -= 1;
YY_DO_BEFORE_ACTION; /* set up fortranscannerYYtext again */
YY_RULE_SETUP
#line 575 "fortranscanner.l"
{
                                          if(YY_START == Start)
                                          {
                                            addModule(NULL); 
                                            yy_push_state(ModuleBody); //anon program
                                          }

                                          yy_push_state(Typedef);
                                          current->protection = defaultProtection;
                                          typeProtection = defaultProtection;
                                          typeMode = true;
                                        }
        YY_BREAK

case 39:
YY_RULE_SETUP
#line 588 "fortranscanner.l"
{}
        YY_BREAK
case 40:
YY_RULE_SETUP
#line 590 "fortranscanner.l"
{}
        YY_BREAK
case 41:
YY_RULE_SETUP
#line 592 "fortranscanner.l"
{
                                          current->spec |= Entry::AbstractClass;
                                        }
        YY_BREAK
case 42:
/* rule 42 can match eol */
YY_RULE_SETUP
#line 595 "fortranscanner.l"
{
                                          QCString basename = extractFromParens(fortranscannerYYtext);
                                          current->extends->append(new BaseInfo(basename, Public, Normal));
                                        }
        YY_BREAK
case 43:
YY_RULE_SETUP
#line 599 "fortranscanner.l"
{
                                          current->protection = Public;
                                          typeProtection = Public;
                                        }
        YY_BREAK
case 44:
YY_RULE_SETUP
#line 603 "fortranscanner.l"
{
                                          current->protection = Private;
                                          typeProtection = Private;
                                        }
        YY_BREAK
case 45:
YY_RULE_SETUP
#line 607 "fortranscanner.l"
{
                                          /* ignored for now */
                                        }
        YY_BREAK
case 46:
YY_RULE_SETUP
#line 610 "fortranscanner.l"
{ /* type name found */
                                          current->section = Entry::CLASS_SEC;
                                          current->spec |= Entry::Struct;
                                          current->name = fortranscannerYYtext;
                                          current->fileName = yyFileName;
                                          current->bodyLine  = yyLineNr; 
                                          current->startLine  = yyLineNr;

                                          /* if type is part of a module, mod name is necessary for output */
                                          if ((current_root) && 
                                              (current_root->section == Entry::CLASS_SEC
                                               || current_root->section == Entry::NAMESPACE_SEC))
                                          {
                                            current->name = current_root->name + "::" + current->name;
                                          }

                                          addCurrentEntry(1);
                                          startScope(last_entry); 
                                          BEGIN(TypedefBody);
                                        }
        YY_BREAK

/* Type Bound Procedures */
case 47:
/* rule 47 can match eol */
YY_RULE_SETUP
#line 633 "fortranscanner.l"
{
                                          current->type = QCString(fortranscannerYYtext).simplifyWhiteSpace();
                                        }
        YY_BREAK
case 48:
YY_RULE_SETUP
#line 636 "fortranscanner.l"
{
                                          current->spec |= Entry::Final;
                                          current->type = QCString(fortranscannerYYtext).simplifyWhiteSpace();
                                        }
        YY_BREAK
case 49:
YY_RULE_SETUP
#line 640 "fortranscanner.l"
{
                                          current->type = QCString(fortranscannerYYtext).simplifyWhiteSpace();
                                        }
        YY_BREAK
case 50:
YY_RULE_SETUP
#line 643 "fortranscanner.l"
{
                                        }
        YY_BREAK
case 51:
/* rule 51 can match eol */
YY_RULE_SETUP
#line 645 "fortranscanner.l"
{
                                          currentModifiers |= QCString(fortranscannerYYtext);
                                        }
        YY_BREAK
case 52:
YY_RULE_SETUP
#line 648 "fortranscanner.l"
{
                                        }
        YY_BREAK
case 53:
YY_RULE_SETUP
#line 650 "fortranscanner.l"
{
                                          QCString name = fortranscannerYYtext;
                                          modifiers[current_root][name.lower()] |= currentModifiers;
                                          current->section  = Entry::FUNCTION_SEC;
                                          current->name     = name;
                                          current->fileName = yyFileName;
                                          current->bodyLine = yyLineNr;
                                          current->startLine  = yyLineNr;
                                          addCurrentEntry(1);
                                        }
        YY_BREAK
case 54:
YY_RULE_SETUP
#line 660 "fortranscanner.l"
{ /* Specific bindings come after the ID. */
                                          last_entry->args = fortranscannerYYtext;
                                        }
        YY_BREAK
case 55:
/* rule 55 can match eol */
YY_RULE_SETUP
#line 663 "fortranscanner.l"
{
                                          currentModifiers = SymbolModifiers();
                                          newLine();
                                          docBlock.resize(0);
                                        }
        YY_BREAK


case 56:
/* rule 56 can match eol */
YY_RULE_SETUP
#line 672 "fortranscanner.l"
{ /* end type definition */
                                          last_entry->parent()->endBodyLine = yyLineNr;
                                          if (!endScope(current_root))
                                            yyterminate();
                                          typeMode = false;
                                          yy_pop_state();
                                        }
        YY_BREAK

/*------- module/global/typedef variable ---------------------------------------------------*/
case 57:
/* rule 57 can match eol */
YY_RULE_SETUP
#line 683 "fortranscanner.l"
{  
                                           //
                                           // ABSTRACT and specific interfaces are stored
                                           // in a scope of their own, even if multiple
                                           // are group in one INTERFACE/END INTERFACE block.
                                           //
                                           last_entry->endBodyLine = yyLineNr - 1;
                                           if (ifType == IF_ABSTRACT || ifType == IF_SPECIFIC)
                                             endScope(current_root);

                                           if (!endScope(current_root))
                                             yyterminate();
                                           subrCurrent.remove(0u);
                                           yy_pop_state() ;
                                        }
        YY_BREAK

case 58:
YY_RULE_SETUP
#line 699 "fortranscanner.l"
{
                                        }
        YY_BREAK


case 59:
/* rule 59 can match eol */
*yy_cp = (yy_hold_char); /* undo effects of setting up fortranscannerYYtext */
(yy_c_buf_p) = yy_cp -= 1;
YY_DO_BEFORE_ACTION; /* set up fortranscannerYYtext again */
YY_RULE_SETUP
#line 703 "fortranscanner.l"
{
                                          current->bodyLine = yyLineNr + 1;
                                          current->endBodyLine = yyLineNr + lineCountPrepass;
                                          /* variable declaration starts */
                                          if(YY_START == Start)
                                          {
                                            addModule(NULL); 
                                            yy_push_state(ModuleBody); //anon program
                                          }
                                          argType = QCString(fortranscannerYYtext).simplifyWhiteSpace().lower();
                                          yy_push_state(AttributeList);
                                        }
        YY_BREAK
/*  Dimitri: macro expansion should already be done during preprocessing not here!
^{BS}{PP_ID}{KIND}?                     { // check for preprocessor symbol expand to type
                                          QCString str = fortranscannerYYtext;
                                          str = str.stripWhiteSpace();
                                          //DefineDict* defines = getGlobalDefineDict();
                                          QCString name;
                                          int index = str.find("(");
                                          if (index != -1)
                                            name = str.left(index).stripWhiteSpace();
                                          else
                                            name = str;

                                          Define *define = 0; //(*defines)[name];
                                          if (define != 0 && isTypeName(define->definition)) 
                                          {
                                            argType = str;
                                            yy_push_state(AttributeList);
                                          } 
                                          else 
                                          {
                                            yyColNr -= (int)fortranscannerYYleng;
                                            REJECT;
                                          }
                                        }
  */
case 60:
*yy_cp = (yy_hold_char); /* undo effects of setting up fortranscannerYYtext */
(yy_c_buf_p) = yy_cp = yy_bp + 8;
YY_DO_BEFORE_ACTION; /* set up fortranscannerYYtext again */
YY_RULE_SETUP
#line 740 "fortranscanner.l"
{ 
                                          /* external can be a "type" or an attribute */
                                          if(YY_START == Start)
                                          {
                                            addModule(NULL); 
                                            yy_push_state(ModuleBody); //anon program
                                          }
                                          QCString tmp = fortranscannerYYtext;
                                          currentModifiers |= tmp.stripWhiteSpace();
                                          argType = QCString(fortranscannerYYtext).simplifyWhiteSpace().lower();
                                          yy_push_state(AttributeList);
                                       }
        YY_BREAK
case 61:
/* rule 61 can match eol */
#line 753 "fortranscanner.l"
case 62:
/* rule 62 can match eol */
YY_RULE_SETUP
#line 753 "fortranscanner.l"
{ 
                                          /* attribute statement starts */
                                          DBG_CTX((stderr,"5=========> Attribute statement: %s\n", fortranscannerYYtext)); 
                                          QCString tmp = fortranscannerYYtext;
                                          currentModifiers |= tmp.stripWhiteSpace();
                                          argType="";
                                          yy_push_state(YY_START);
                                          BEGIN( AttributeList ) ;
                                       }
        YY_BREAK
case 63:
YY_RULE_SETUP
#line 762 "fortranscanner.l"
{
                                       }  
        YY_BREAK
case 64:
YY_RULE_SETUP
#line 764 "fortranscanner.l"
{ }
        YY_BREAK
case 65:
YY_RULE_SETUP
#line 765 "fortranscanner.l"
{ }
        YY_BREAK


case 66:
YY_RULE_SETUP
#line 768 "fortranscanner.l"
{}
        YY_BREAK
case 67:
YY_RULE_SETUP
#line 769 "fortranscanner.l"
{}
        YY_BREAK
case 68:
/* rule 68 can match eol */
YY_RULE_SETUP
#line 770 "fortranscanner.l"
{ /* update current modifiers when it is an ATTR_SPEC and not a variable name */
                                          /* bug_625519 */
                                          QChar chr = fortranscannerYYtext[(int)fortranscannerYYleng-1];
                                          if (chr.isLetter() || chr.isDigit() || (chr == '_'))
                                          {
                                            yyColNr -= (int)fortranscannerYYleng;
                                            REJECT;
                                          }
                                          else
                                          {
                                            QCString tmp = fortranscannerYYtext;
                                            tmp = tmp.left(tmp.length() - 1);
                                            yyColNr -= 1;
                                            unput(fortranscannerYYtext[(int)fortranscannerYYleng-1]);
                                            currentModifiers |= (tmp);
                                          }
                                        }
        YY_BREAK
case 69:
YY_RULE_SETUP
#line 787 "fortranscanner.l"
{ /* end attribute list */
                                          BEGIN( Variable );
                                        }
        YY_BREAK
case 70:
YY_RULE_SETUP
#line 790 "fortranscanner.l"
{ /* unknown attribute, consider variable name */
                                          //cout<<"start variables, unput "<<*fortranscannerYYtext<<endl;
                                          yyColNr -= 1;
                                          unput(*fortranscannerYYtext);
                                          BEGIN( Variable );
                                        }
        YY_BREAK

case 71:
YY_RULE_SETUP
#line 798 "fortranscanner.l"
{ }
        YY_BREAK
case 72:
YY_RULE_SETUP
#line 799 "fortranscanner.l"
{ /* parse variable declaration */
                                          //cout << "5=========> got variable: " << argType << "::" << fortranscannerYYtext << endl;
                                          /* work around for bug in QCString.replace (QCString works) */
                                          QCString name=fortranscannerYYtext;
                                          name = name.lower();
                                          /* remember attributes for the symbol */
                                          modifiers[current_root][name.lower()] |= currentModifiers;
                                          argName= name;

                                          v_type= V_IGNORE;
                                          if (!argType.isEmpty() && current_root->section!=Entry::FUNCTION_SEC) 
                                          { // new variable entry
                                            v_type = V_VARIABLE;
                                            current->section = Entry::VARIABLE_SEC;
                                            current->name = argName;
                                            current->type = argType;
                                            current->fileName = yyFileName;
                                            current->bodyLine  = yyLineNr; // used for source reference
                                            current->startLine  = yyLineNr;
                                            addCurrentEntry(1);
                                          } 
                                          else if (!argType.isEmpty())
                                          { // declaration of parameter list: add type for corr. parameter 
                                            parameter = getParameter(argName);
                                            if (parameter) 
                                            {
                                              v_type= V_PARAMETER;
                                              if (!argType.isNull()) parameter->type=argType.stripWhiteSpace();
                                              if (!docBlock.isNull()) 
                                              {
                                                subrHandleCommentBlock(docBlock,TRUE);
                                              }                                     
                                            }
                                            // save, it may be function return type
                                            if (parameter)
                                            {
                                              modifiers[current_root][name.lower()].type = argType;
                                            }
                                            else
                                            {
                                              if ((current_root->name.lower() == argName.lower()) ||
                                                  (modifiers[current_root->parent()][current_root->name.lower()].returnName.lower() == argName.lower()))
                                              {
                                                int strt = current_root->type.find("function");
                                                QCString lft;
                                                QCString rght;
                                                if (strt != -1)
                                                {
                                                  v_type = V_RESULT;
                                                  lft = "";
                                                  rght = "";
                                                  if (strt != 0) lft = current_root->type.left(strt).stripWhiteSpace();
                                                  if ((current_root->type.length() - strt - strlen("function"))!= 0)
                                                  {
                                                    rght = current_root->type.right(current_root->type.length() - strt - strlen("function")).stripWhiteSpace();
                                                  }
                                                  current_root->type = lft;
                                                  if (rght.length() > 0)
                                                  {
                                                    if (current_root->type.length() > 0) current_root->type += " ";
                                                    current_root->type += rght;
                                                  }
                                                  if (argType.stripWhiteSpace().length() > 0)
                                                  {
                                                    if (current_root->type.length() > 0) current_root->type += " ";
                                                    current_root->type += argType.stripWhiteSpace();
                                                  }
                                                  if (current_root->type.length() > 0) current_root->type += " ";
                                                  current_root->type += "function";
                                                  if (!docBlock.isNull()) 
                                                  {
                                                    subrHandleCommentBlockResult(docBlock,TRUE);
                                                  }
                                                }
                                                else
                                                {
                                                  current_root->type += " " + argType.stripWhiteSpace();
                                                }
                                                current_root->type = current_root->type.stripWhiteSpace();
                                                modifiers[current_root][name.lower()].type = current_root->type;
                                              }
                                              else
                                              {
                                                modifiers[current_root][name.lower()].type = argType;
                                              }
                                            }
                                            // any accumulated doc for argument should be emptied,
                                            // because it is handled other way and this doc can be
                                            // unexpectedly passed to the next member.
                                            current->doc.resize(0);
                                            current->brief.resize(0);
                                          } 
                                        }
        YY_BREAK
case 73:
/* rule 73 can match eol */
YY_RULE_SETUP
#line 892 "fortranscanner.l"
{ /* dimension of the previous entry. */
                                          QCString name(argName);
                                          QCString attr("dimension");
                                          attr += fortranscannerYYtext;
                                          modifiers[current_root][name.lower()] |= attr;
                                        }
        YY_BREAK
case 74:
YY_RULE_SETUP
#line 898 "fortranscanner.l"
{ //printf("COMMA: %d<=..<=%d\n", yyColNr-(int)fortranscannerYYleng, yyColNr);
                                          // locate !< comment
                                          updateVariablePrepassComment(yyColNr-(int)fortranscannerYYleng, yyColNr);
                                        }
        YY_BREAK
case 75:
YY_RULE_SETUP
#line 902 "fortranscanner.l"
{
                                          yy_push_state(YY_START);
                                          initializer="=";
                                          initializerScope = initializerArrayScope = 0;
                                          BEGIN(Initialization);
                                        }
        YY_BREAK
case 76:
/* rule 76 can match eol */
YY_RULE_SETUP
#line 908 "fortranscanner.l"
{ currentModifiers = SymbolModifiers();
                                          yy_pop_state(); // end variable declaration list
                                          newLine();
                                          docBlock.resize(0);
                                        }
        YY_BREAK
case 77:
/* rule 77 can match eol */
YY_RULE_SETUP
#line 913 "fortranscanner.l"
{ currentModifiers = SymbolModifiers();
                                          yy_pop_state(); // end variable declaration list
                                          docBlock.resize(0);
                                          inputStringSemi =(const char*)(QCString(" \n") + QCString(fortranscannerYYtext+1)).data();
                                          yyLineNr--;
                                          pushBuffer(inputStringSemi);
                                        }
        YY_BREAK
case 78:
/* rule 78 can match eol */
YY_RULE_SETUP
#line 920 "fortranscanner.l"
{
                                          if (YY_START == Variable) REJECT; // Just be on the safe side
                                          if (YY_START == String) REJECT; // ";" ignored in strings
                                          if (YY_START == StrIgnore) REJECT; // ";" ignored in regular comments
                                          inputStringSemi =(const char*)(QCString(" \n") + QCString(fortranscannerYYtext+1)).data();
                                          yyLineNr--;
                                          pushBuffer(inputStringSemi);
                                        }
        YY_BREAK
case 79:
#line 930 "fortranscanner.l"
case 80:
YY_RULE_SETUP
#line 930 "fortranscanner.l"
{ initializer+=fortranscannerYYtext;
                                           initializerArrayScope++;
                                           BEGIN(ArrayInitializer); // initializer may contain comma
                                        }
        YY_BREAK
case 81:
#line 935 "fortranscanner.l"
case 82:
YY_RULE_SETUP
#line 935 "fortranscanner.l"
{ initializer+=fortranscannerYYtext;
                                           initializerArrayScope--;
                                           if(initializerArrayScope<=0)
                                           {
                                              initializerArrayScope = 0; // just in case
                                              BEGIN(Initialization);
                                           }
                                        }
        YY_BREAK
case 83:
YY_RULE_SETUP
#line 943 "fortranscanner.l"
{ initializer+=fortranscannerYYtext; }
        YY_BREAK
case 84:
YY_RULE_SETUP
#line 944 "fortranscanner.l"
{ initializerScope++;
                                          initializer+=fortranscannerYYtext;
                                        }
        YY_BREAK
case 85:
YY_RULE_SETUP
#line 947 "fortranscanner.l"
{ initializerScope--;
                                          initializer+=fortranscannerYYtext;
                                        }
        YY_BREAK
case 86:
YY_RULE_SETUP
#line 950 "fortranscanner.l"
{ if (initializerScope == 0)
                                          {
                                            updateVariablePrepassComment(yyColNr-(int)fortranscannerYYleng, yyColNr);
                                            yy_pop_state(); // end initialization
                                            if (v_type == V_VARIABLE) last_entry->initializer= initializer;
                                          }
                                          else
                                            initializer+=", ";
                                        }
        YY_BREAK
case 87:
/* rule 87 can match eol */
YY_RULE_SETUP
#line 959 "fortranscanner.l"
{ //|
                                          yy_pop_state(); // end initialization
                                          if (v_type == V_VARIABLE) last_entry->initializer= initializer;
                                          yyColNr -= 1;
                                          unput(*fortranscannerYYtext);
                                        }
        YY_BREAK
case 88:
YY_RULE_SETUP
#line 965 "fortranscanner.l"
{ initializer+=fortranscannerYYtext; }
        YY_BREAK
/*------ fortran subroutine/function handling ------------------------------------------------------------*/
/*       Start is initial condition                                                                       */
case 89:
/* rule 89 can match eol */
YY_RULE_SETUP
#line 970 "fortranscanner.l"
{
                                         if (ifType == IF_ABSTRACT || ifType == IF_SPECIFIC)
                                         {
                                           addInterface("$interface$", ifType);
                                           startScope(last_entry);
                                         }

                                         // TYPE_SPEC is for old function style function result
                                         result = QCString(fortranscannerYYtext).stripWhiteSpace().lower();
                                         current->type = result;
                                         yy_push_state(SubprogPrefix);
                                       }
        YY_BREAK
case 90:
YY_RULE_SETUP
#line 983 "fortranscanner.l"
{
                                         // Fortran subroutine or function found
                                         v_type = V_IGNORE;
                                         result=fortranscannerYYtext;
                                         result=result.stripWhiteSpace();
                                         addSubprogram(result);
                                         BEGIN(Subprog);
                                         current->bodyLine = yyLineNr + lineCountPrepass + 1; // we have to be at the line after the definition and we have to take continuation lines into account.
                                         current->startLine = yyLineNr;
                                       }
        YY_BREAK
case 91:
YY_RULE_SETUP
#line 994 "fortranscanner.l"
{
                                         // Fortran subroutine or function found
                                         v_type = V_IGNORE;
                                         if (ifType == IF_ABSTRACT || ifType == IF_SPECIFIC)
                                         {
                                           addInterface("$interface$", ifType);
                                           startScope(last_entry);
                                         }

                                         result = QCString(fortranscannerYYtext).stripWhiteSpace();
                                         addSubprogram(result);
                                         yy_push_state(Subprog);
                                         current->bodyLine = yyLineNr + lineCountPrepass + 1; // we have to be at the line after the definition and we have to take continuation lines into account.
                                         current->startLine = yyLineNr;
                                       }
        YY_BREAK
case 92:
YY_RULE_SETUP
#line 1010 "fortranscanner.l"
{   /* ignore white space */   }
        YY_BREAK
case 93:
YY_RULE_SETUP
#line 1011 "fortranscanner.l"
{ current->name = fortranscannerYYtext;
                                         //cout << "1a==========> got " << current->type << " " << fortranscannerYYtext << " " << yyLineNr << endl;
                                         modifiers[current_root][current->name.lower()].returnName = current->name.lower();

                                         if (ifType == IF_ABSTRACT || ifType == IF_SPECIFIC)
                                         {
                                           current_root->name.replace(QRegExp("\\$interface\\$"), fortranscannerYYtext);
                                         }

                                         BEGIN(Parameterlist);
                                       }
        YY_BREAK
case 94:
YY_RULE_SETUP
#line 1022 "fortranscanner.l"
{ current->args = "("; }
        YY_BREAK
case 95:
YY_RULE_SETUP
#line 1023 "fortranscanner.l"
{
                                         current->args += ")";
                                         current->args = removeRedundantWhiteSpace(current->args);
                                         addCurrentEntry(1);
                                         startScope(last_entry);
                                         BEGIN(SubprogBody);
                                       }
        YY_BREAK
case 96:
YY_RULE_SETUP
#line 1030 "fortranscanner.l"
{ current->args += fortranscannerYYtext;
                                         CommentInPrepass *c = locatePrepassComment(yyColNr-(int)fortranscannerYYleng, yyColNr);
                                         if (c!=NULL) {
                                           if(current->argList->count()>0) {
                                             current->argList->at(current->argList->count()-1)->docs = c->str;
                                           }
                                         }                       
                                       }
        YY_BREAK
case 97:
YY_RULE_SETUP
#line 1038 "fortranscanner.l"
{
                                           //current->type not yet available
                                           QCString param = fortranscannerYYtext;
                                           // std::cout << "3=========> got parameter " << param << std::endl;
                                           current->args += param;
                                           Argument *arg = new Argument;
                                           arg->name = param;
                                           arg->type = "";
                                           current->argList->append(arg);
                                       } 
        YY_BREAK
case 98:
/* rule 98 can match eol */
YY_RULE_SETUP
#line 1048 "fortranscanner.l"
{   
                                           newLine();
                                           //printf("3=========> without parameterlist \n");
                                           //current->argList = ;
                                           addCurrentEntry(1);
                                           startScope(last_entry);
                                           BEGIN(SubprogBody);                                     
}
        YY_BREAK
case 99:
YY_RULE_SETUP
#line 1056 "fortranscanner.l"
{  
                                           if (functionLine)
                                           {
                                             result= fortranscannerYYtext;
                                             result= result.right(result.length()-result.find("(")-1);
                                             result= result.stripWhiteSpace();
                                             modifiers[current_root->parent()][current_root->name.lower()].returnName = result;
                                           }
                                           //cout << "=====> got result " <<  result << endl;
                                       } 
        YY_BREAK
/*---- documentation comments --------------------------------------------------------------------*/
case 100:
YY_RULE_SETUP
#line 1069 "fortranscanner.l"
{ /* backward docu comment */
                                          if (v_type != V_IGNORE) {
                                           current->docLine  = yyLineNr;
                                           docBlockJavaStyle = FALSE;
                                           docBlock.resize(0);
                                           docBlockJavaStyle = Config_getBool("JAVADOC_AUTOBRIEF");
                                           startCommentBlock(TRUE);
                                           yy_push_state(DocBackLine);
                                          }
                                          else
                                          {
                                            /* handle out of place !< comment as a normal comment */
                                            if (YY_START == String) { yyColNr -= (int)fortranscannerYYleng; REJECT; } // "!" is ignored in strings
                                            // skip comment line (without docu comments "!>" "!<" ) 
                                            /* ignore further "!" and ignore comments in Strings */
                                            if ((YY_START != StrIgnore) && (YY_START != String)) 
                                            {
                                              yy_push_state(YY_START);
                                              BEGIN(StrIgnore); 
                                              debugStr="*!";
                                              //fprintf(stderr,"start comment %d\n",yyLineNr);
                                            }      
                                          }
                                         }
        YY_BREAK
case 101:
YY_RULE_SETUP
#line 1093 "fortranscanner.l"
{ // contents of current comment line
                                          docBlock+=fortranscannerYYtext;
                                        }
        YY_BREAK
case 102:
/* rule 102 can match eol */
YY_RULE_SETUP
#line 1096 "fortranscanner.l"
{ // comment block (next line is also comment line)
                                          docBlock+="\n"; // \n is necessary for lists
                                          newLine();
                                        }
        YY_BREAK
case 103:
/* rule 103 can match eol */
YY_RULE_SETUP
#line 1100 "fortranscanner.l"
{ // comment block ends at the end of this line
                                          //cout <<"3=========> comment block : "<< docBlock << endl;
                                          yyColNr -= 1;
                                          unput(*fortranscannerYYtext);                                        
                                          if (v_type == V_VARIABLE) 
                                          {
                                            Entry *tmp_entry = current; 
                                            current = last_entry; // temporarily switch to the previous entry
                                            handleCommentBlock(docBlock,TRUE);
                                            current=tmp_entry;
                                          }
                                          else if (v_type == V_PARAMETER) 
                                          {
                                            subrHandleCommentBlock(docBlock,TRUE);
                                          }
                                          else if (v_type == V_RESULT) 
                                          {
                                            subrHandleCommentBlockResult(docBlock,TRUE);
                                          }
                                          yy_pop_state();
                                          docBlock.resize(0);
                                        }
        YY_BREAK
case 104:
YY_RULE_SETUP
#line 1123 "fortranscanner.l"
{
                                          yy_push_state(YY_START);
                                          current->docLine  = yyLineNr;
                                          docBlockJavaStyle = FALSE;
                                          if (YY_START==SubprogBody) docBlockInBody = TRUE;
                                          docBlock.resize(0);
                                          docBlockJavaStyle = Config_getBool("JAVADOC_AUTOBRIEF");
                                          startCommentBlock(TRUE);
                                          BEGIN(DocBlock);
                                          //cout << "start DocBlock " << endl;
                                        }
        YY_BREAK
case 105:
YY_RULE_SETUP
#line 1135 "fortranscanner.l"
{ // contents of current comment line
                                          docBlock+=fortranscannerYYtext;
                                        }
        YY_BREAK
case 106:
/* rule 106 can match eol */
YY_RULE_SETUP
#line 1138 "fortranscanner.l"
{ // comment block (next line is also comment line)
                                          docBlock+="\n"; // \n is necessary for lists
                                          newLine();
                                        }
        YY_BREAK
case 107:
/* rule 107 can match eol */
YY_RULE_SETUP
#line 1142 "fortranscanner.l"
{ // comment block ends at the end of this line
                                          //cout <<"3=========> comment block : "<< docBlock << endl;
                                          yyColNr -= 1;
                                          unput(*fortranscannerYYtext);                                        
                                          handleCommentBlock(docBlock,TRUE);
                                          yy_pop_state();                                          
                                        }
        YY_BREAK
/*-----Prototype parsing -------------------------------------------------------------------------*/
case 108:
YY_RULE_SETUP
#line 1151 "fortranscanner.l"
{
                                          BEGIN(PrototypeSubprog);
                                        }
        YY_BREAK
case 109:
YY_RULE_SETUP
#line 1154 "fortranscanner.l"
{ 
                                          current->name = QCString(fortranscannerYYtext).lower();
                                          current->name.stripWhiteSpace();
                                          BEGIN(PrototypeArgs);
                                        }
        YY_BREAK

case 110:
YY_RULE_SETUP
#line 1160 "fortranscanner.l"
{ current->args += fortranscannerYYtext; }
        YY_BREAK
case 111:
YY_RULE_SETUP
#line 1161 "fortranscanner.l"
{ current->args += fortranscannerYYtext; 
                                          Argument *a = new Argument;
                                          a->name = QCString(fortranscannerYYtext).lower();
                                          current->argList->append(a);
                                        }
        YY_BREAK

/*------------------------------------------------------------------------------------------------*/
case 112:
/* rule 112 can match eol */
YY_RULE_SETUP
#line 1170 "fortranscanner.l"
{
                                          newLine();
                                          //if (debugStr.stripWhiteSpace().length() > 0) cout << "ignored text: " << debugStr << " state: " <<YY_START << endl;
                                          debugStr="";
                                        }
        YY_BREAK
/*---- error: EOF in wrong state --------------------------------------------------------------------*/
case YY_STATE_EOF(INITIAL):
case YY_STATE_EOF(Subprog):
case YY_STATE_EOF(SubprogPrefix):
case YY_STATE_EOF(Parameterlist):
case YY_STATE_EOF(SubprogBody):
case YY_STATE_EOF(SubprogBodyContains):
case YY_STATE_EOF(Start):
case YY_STATE_EOF(Comment):
case YY_STATE_EOF(Module):
case YY_STATE_EOF(Program):
case YY_STATE_EOF(ModuleBody):
case YY_STATE_EOF(ModuleBodyContains):
case YY_STATE_EOF(AttributeList):
case YY_STATE_EOF(Variable):
case YY_STATE_EOF(Initialization):
case YY_STATE_EOF(ArrayInitializer):
case YY_STATE_EOF(Typedef):
case YY_STATE_EOF(TypedefBody):
case YY_STATE_EOF(TypedefBodyContains):
case YY_STATE_EOF(InterfaceBody):
case YY_STATE_EOF(StrIgnore):
case YY_STATE_EOF(String):
case YY_STATE_EOF(Use):
case YY_STATE_EOF(UseOnly):
case YY_STATE_EOF(ModuleProcedure):
case YY_STATE_EOF(Prepass):
case YY_STATE_EOF(DocBlock):
case YY_STATE_EOF(DocBackLine):
case YY_STATE_EOF(EndDoc):
case YY_STATE_EOF(BlockData):
case YY_STATE_EOF(Prototype):
case YY_STATE_EOF(PrototypeSubprog):
case YY_STATE_EOF(PrototypeArgs):
#line 1179 "fortranscanner.l"
{
                                          if (parsingPrototype) {
                                            yyterminate();

                                          } else if ( include_stack_ptr <= 0 ) {
                                            if (YY_START!=INITIAL && YY_START!=Start) {
                                              DBG_CTX((stderr,"==== Error: EOF reached in wrong state (end missing)"));
                                              scanner_abort();
                                            }
                                            yyterminate();
                                          } else {
                                            popBuffer();
                                          }
                                        }
        YY_BREAK
case 113:
YY_RULE_SETUP
#line 1193 "fortranscanner.l"
{ // Fortran logical comparison keywords
                                        }
        YY_BREAK
case 114:
YY_RULE_SETUP
#line 1195 "fortranscanner.l"
{
                                          //debugStr+=fortranscannerYYtext;
                                          //printf("I:%c\n", *fortranscannerYYtext);
                                        } // ignore remaining text 
        YY_BREAK
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
case 115:
YY_RULE_SETUP
#line 1203 "fortranscanner.l"
ECHO;
        YY_BREAK
#line 58442 "/nova/app/home/novasoft/doxygen/doxygen-1.8.11/build/generated_src/fortranscanner.cpp"

        case YY_END_OF_BUFFER:
                {
                /* Amount of text matched not including the EOB char. */
                int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;

                /* Undo the effects of YY_DO_BEFORE_ACTION. */
                *yy_cp = (yy_hold_char);
                YY_RESTORE_YY_MORE_OFFSET

                if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
                        {
                        /* We're scanning a new file or input source.  It's
                         * possible that this happened because the user
                         * just pointed fortranscannerYYin at a new source and called
                         * fortranscannerYYlex().  If so, then we have to assure
                         * consistency between YY_CURRENT_BUFFER and our
                         * globals.  Here is the right place to do so, because
                         * this is the first action (other than possibly a
                         * back-up) that will match for the new input source.
                         */
                        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
                        YY_CURRENT_BUFFER_LVALUE->yy_input_file = fortranscannerYYin;
                        YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
                        }

                /* Note that here we test for yy_c_buf_p "<=" to the position
                 * of the first EOB in the buffer, since yy_c_buf_p will
                 * already have been incremented past the NUL character
                 * (since all states make transitions on EOB to the
                 * end-of-buffer state).  Contrast this with the test
                 * in input().
                 */
                if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
                        { /* This was really a NUL. */
                        yy_state_type yy_next_state;

                        (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;

                        yy_current_state = yy_get_previous_state(  );

                        /* Okay, we're now positioned to make the NUL
                         * transition.  We couldn't have
                         * yy_get_previous_state() go ahead and do it
                         * for us because it doesn't know how to deal
                         * with the possibility of jamming (and we don't
                         * want to build jamming into it because then it
                         * will run more slowly).
                         */

                        yy_next_state = yy_try_NUL_trans( yy_current_state );

                        yy_bp = (yytext_ptr) + YY_MORE_ADJ;

                        if ( yy_next_state )
                                {
                                /* Consume the NUL. */
                                yy_cp = ++(yy_c_buf_p);
                                yy_current_state = yy_next_state;
                                goto yy_match;
                                }

                        else
                                {
                                yy_cp = (yy_c_buf_p);
                                goto yy_find_action;
                                }
                        }

                else switch ( yy_get_next_buffer(  ) )
                        {
                        case EOB_ACT_END_OF_FILE:
                                {
                                (yy_did_buffer_switch_on_eof) = 0;

                                if ( fortranscannerYYwrap( ) )
                                        {
                                        /* Note: because we've taken care in
                                         * yy_get_next_buffer() to have set up
                                         * fortranscannerYYtext, we can now set up
                                         * yy_c_buf_p so that if some total
                                         * hoser (like flex itself) wants to
                                         * call the scanner after we return the
                                         * YY_NULL, it'll still work - another
                                         * YY_NULL will get returned.
                                         */
                                        (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;

                                        yy_act = YY_STATE_EOF(YY_START);
                                        goto do_action;
                                        }

                                else
                                        {
                                        if ( ! (yy_did_buffer_switch_on_eof) )
                                                YY_NEW_FILE;
                                        }
                                break;
                                }

                        case EOB_ACT_CONTINUE_SCAN:
                                (yy_c_buf_p) =
                                        (yytext_ptr) + yy_amount_of_matched_text;

                                yy_current_state = yy_get_previous_state(  );

                                yy_cp = (yy_c_buf_p);
                                yy_bp = (yytext_ptr) + YY_MORE_ADJ;
                                goto yy_match;

                        case EOB_ACT_LAST_MATCH:
                                (yy_c_buf_p) =
                                &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];

                                yy_current_state = yy_get_previous_state(  );

                                yy_cp = (yy_c_buf_p);
                                yy_bp = (yytext_ptr) + YY_MORE_ADJ;
                                goto yy_find_action;
                        }
                break;
                }

        default:
                YY_FATAL_ERROR(
                        "fatal flex scanner internal error--no action found" );
        } /* end of action switch */
                } /* end of scanning one token */

static void yy_fatal_error ( yyconst char  msg[] )

static

static void yy_fatal_error ( yyconst char *  msg )

static

Definition at line 59238 of file fortranscanner.cpp.

{
        (void) fprintf( stderr, "%s\n", msg );
        exit( YY_EXIT_FAILURE );
}

static int yy_get_next_buffer ( void  )

static

Definition at line 58579 of file fortranscanner.cpp.

{
        register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
        register char *source = (yytext_ptr);
        register int number_to_move, i;
        int ret_val;

        if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
                YY_FATAL_ERROR(
                "fatal flex scanner internal error--end of buffer missed" );

        if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
                { /* Don't try to fill the buffer, so this is an EOF. */
                if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
                        {
                        /* We matched a single character, the EOB, so
                         * treat this as a final EOF.
                         */
                        return EOB_ACT_END_OF_FILE;
                        }

                else
                        {
                        /* We matched some text prior to the EOB, first
                         * process it.
                         */
                        return EOB_ACT_LAST_MATCH;
                        }
                }

        /* Try to read more data. */

        /* First move last chars to start of buffer. */
        number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;

        for ( i = 0; i < number_to_move; ++i )
                *(dest++) = *(source++);

        if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
                /* don't do the read, it's not guaranteed to return an EOF,
                 * just force an EOF
                 */
                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;

        else
                {
                        int num_to_read =
                        YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;

                while ( num_to_read <= 0 )
                        { /* Not enough room in the buffer - grow it. */

                        YY_FATAL_ERROR(
"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );

                        }

                if ( num_to_read > YY_READ_BUF_SIZE )
                        num_to_read = YY_READ_BUF_SIZE;

                /* Read in more data. */
                YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
                        (yy_n_chars), (size_t) num_to_read );

                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
                }

        if ( (yy_n_chars) == 0 )
                {
                if ( number_to_move == YY_MORE_ADJ )
                        {
                        ret_val = EOB_ACT_END_OF_FILE;
                        fortranscannerYYrestart(fortranscannerYYin  );
                        }

                else
                        {
                        ret_val = EOB_ACT_LAST_MATCH;
                        YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
                                YY_BUFFER_EOF_PENDING;
                        }
                }

        else
                ret_val = EOB_ACT_CONTINUE_SCAN;

        if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
                /* Extend the array by 50%, plus the number we really need. */
                yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
                YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) fortranscannerYYrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
                if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
                        YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
        }

        (yy_n_chars) += number_to_move;
        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;

        (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];

        return ret_val;
}

static yy_state_type yy_get_previous_state ( void  )

static

Definition at line 58684 of file fortranscanner.cpp.

{
        register yy_state_type yy_current_state;
        register char *yy_cp;
    
        yy_current_state = (yy_start);
        yy_current_state += YY_AT_BOL();

        (yy_state_ptr) = (yy_state_buf);
        *(yy_state_ptr)++ = yy_current_state;

        for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
                {
                register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
                while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                        {
                        yy_current_state = (int) yy_def[yy_current_state];
                        if ( yy_current_state >= 24248 )
                                yy_c = yy_meta[(unsigned int) yy_c];
                        }
                yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
                *(yy_state_ptr)++ = yy_current_state;
                }

        return yy_current_state;
}

static int yy_init_globals ( void  )

static

Definition at line 59341 of file fortranscanner.cpp.

{
        /* Initialization is the same as for the non-reentrant scanner.
     * This function is called from fortranscannerYYlex_destroy(), so don't allocate here.
     */

    (yy_buffer_stack) = 0;
    (yy_buffer_stack_top) = 0;
    (yy_buffer_stack_max) = 0;
    (yy_c_buf_p) = (char *) 0;
    (yy_init) = 0;
    (yy_start) = 0;

    (yy_start_stack_ptr) = 0;
    (yy_start_stack_depth) = 0;
    (yy_start_stack) =  NULL;

    (yy_state_buf) = 0;
    (yy_state_ptr) = 0;
    (yy_full_match) = 0;
    (yy_lp) = 0;

/* Defined in main.c */
#ifdef YY_STDINIT
    fortranscannerYYin = stdin;
    fortranscannerYYout = stdout;
#else
    fortranscannerYYin = (FILE *) 0;
    fortranscannerYYout = (FILE *) 0;
#endif

    /* For future reference: Set errno on error, since we are called by
     * fortranscannerYYlex_init()
     */
    return 0;
}

static void yy_pop_state ( void  )

static

Definition at line 59221 of file fortranscanner.cpp.

{
        if ( --(yy_start_stack_ptr) < 0 )
                YY_FATAL_ERROR( "start-condition stack underflow" );

        BEGIN((yy_start_stack)[(yy_start_stack_ptr)]);
}

static void yy_push_state ( int  new_state )

static

Definition at line 59197 of file fortranscanner.cpp.

{
        if ( (yy_start_stack_ptr) >= (yy_start_stack_depth) )
                {
                yy_size_t new_size;

                (yy_start_stack_depth) += YY_START_STACK_INCR;
                new_size = (yy_start_stack_depth) * sizeof( int );

                if ( ! (yy_start_stack) )
                        (yy_start_stack) = (int *) fortranscannerYYalloc(new_size  );

                else
                        (yy_start_stack) = (int *) fortranscannerYYrealloc((void *) (yy_start_stack),new_size  );

                if ( ! (yy_start_stack) )
                        YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
                }

        (yy_start_stack)[(yy_start_stack_ptr)++] = YY_START;

        BEGIN(new_state);
}

static int yy_top_state ( void  )

static

Definition at line 59229 of file fortranscanner.cpp.

{
        return (yy_start_stack)[(yy_start_stack_ptr) - 1];
}

static yy_state_type yy_try_NUL_trans ( yy_state_type  current_state )

static

Definition at line 58716 of file fortranscanner.cpp.

{
        register int yy_is_jam;
    
        register YY_CHAR yy_c = 1;
        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                {
                yy_current_state = (int) yy_def[yy_current_state];
                if ( yy_current_state >= 24248 )
                        yy_c = yy_meta[(unsigned int) yy_c];
                }
        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
        yy_is_jam = (yy_current_state == 24247);
        if ( ! yy_is_jam )
                *(yy_state_ptr)++ = yy_current_state;

        return yy_is_jam ? 0 : yy_current_state;
}

static int yyread ( char *  buf, int  max_size  )

static

Definition at line 60319 of file fortranscanner.cpp.

{
  int c=0;

  while ( c < max_size && inputString[inputPosition] )
  {
    *buf = inputString[inputPosition++] ;
    c++; buf++;
  }
  return c;
}

static void yyunput ( int  c, char *  buf_ptr  )

static

static void yyunput ( int  c, register char *  yy_bp  )

static

Definition at line 58735 of file fortranscanner.cpp.

{
        register char *yy_cp;
    
    yy_cp = (yy_c_buf_p);

        /* undo effects of setting up fortranscannerYYtext */
        *yy_cp = (yy_hold_char);

        if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
                { /* need to shift things up to make room */
                /* +2 for EOB chars. */
                register int number_to_move = (yy_n_chars) + 2;
                register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
                                        YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
                register char *source =
                                &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];

                while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
                        *--dest = *--source;

                yy_cp += (int) (dest - source);
                yy_bp += (int) (dest - source);
                YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
                        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;

                if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
                        YY_FATAL_ERROR( "flex scanner push-back overflow" );
                }

        *--yy_cp = (char) c;

        (yytext_ptr) = yy_bp;
        (yy_hold_char) = *yy_cp;
        (yy_c_buf_p) = yy_cp;
}

Variable Documentation

QCString argName

static

Definition at line 56617 of file fortranscanner.cpp.

QCString argType

static

Definition at line 56616 of file fortranscanner.cpp.

QList<CommentInPrepass> comments

static

Definition at line 56587 of file fortranscanner.cpp.

Entry* current = 0

static

Definition at line 56600 of file fortranscanner.cpp.

Entry* current_root = 0

static

Definition at line 56597 of file fortranscanner.cpp.

SymbolModifiers currentModifiers

static

Accumulated modifiers of current statement, eg variable declaration.

Definition at line 56632 of file fortranscanner.cpp.

QCString debugStr

static

Definition at line 56613 of file fortranscanner.cpp.

Protection defaultProtection

static

Definition at line 56622 of file fortranscanner.cpp.

const char* directionParam[]

static

Initial value:

= 
{
   "", "[in]", "[out]", "[in,out]"
}

Definition at line 56560 of file fortranscanner.cpp.

const char* directionStrs[]

static

Initial value:

= 
{
   "", "intent(in)", "intent(out)", "intent(inout)"
}

Definition at line 56556 of file fortranscanner.cpp.

QCString docBlock

static

Definition at line 56605 of file fortranscanner.cpp.

bool docBlockInBody = FALSE

static

Definition at line 56606 of file fortranscanner.cpp.

bool docBlockJavaStyle

static

Definition at line 56607 of file fortranscanner.cpp.

Entry* file_root = 0

static

Definition at line 56599 of file fortranscanner.cpp.

int fortranscannerYY_flex_debug = 0

Definition at line 56415 of file fortranscanner.cpp.

FILE * fortranscannerYYin = (FILE *) 0

Definition at line 359 of file fortranscanner.cpp.

int fortranscannerYYleng

Definition at line 294 of file fortranscanner.cpp.

int fortranscannerYYlineno = 1

Definition at line 365 of file fortranscanner.cpp.

FILE * fortranscannerYYout = (FILE *) 0

Definition at line 359 of file fortranscanner.cpp.

char * fortranscannerYYtext

Definition at line 56439 of file fortranscanner.cpp.

bool functionLine = FALSE

static

Definition at line 56626 of file fortranscanner.cpp.

ParserInterface* g_thisParser

static

Definition at line 56571 of file fortranscanner.cpp.

Entry* global_root = 0

static

Definition at line 56598 of file fortranscanner.cpp.

bool gstat

static

Definition at line 56610 of file fortranscanner.cpp.

InterfaceType ifType = IF_NONE

static

Definition at line 56625 of file fortranscanner.cpp.

YY_BUFFER_STATE* include_stack = NULL

Definition at line 56589 of file fortranscanner.cpp.

int include_stack_cnt = 0

Definition at line 56591 of file fortranscanner.cpp.

int include_stack_ptr = 0

Definition at line 56590 of file fortranscanner.cpp.

QCString initializer

static

Definition at line 56618 of file fortranscanner.cpp.

int initializerArrayScope

static

Definition at line 56619 of file fortranscanner.cpp.

int initializerScope

static

Definition at line 56620 of file fortranscanner.cpp.

QFile inputFile

static

Definition at line 56593 of file fortranscanner.cpp.

int inputPosition

static

Definition at line 56573 of file fortranscanner.cpp.

unsigned int inputPositionPrepass

static

Definition at line 56577 of file fortranscanner.cpp.

const char* inputString

static

Definition at line 56572 of file fortranscanner.cpp.

QCString inputStringPrepass

static

Input string for prepass of line cont. '&'.

Definition at line 56575 of file fortranscanner.cpp.

QCString inputStringSemi

static

Input string after command separetor ';'.

Definition at line 56576 of file fortranscanner.cpp.

bool isFixedForm

static

Definition at line 56574 of file fortranscanner.cpp.

Entry* last_entry = 0

static

Definition at line 56601 of file fortranscanner.cpp.

int lineCountPrepass = 0

static

Definition at line 56578 of file fortranscanner.cpp.

QMap<Entry*,QMap<QCString,SymbolModifiers> > modifiers

static

Holds program scope->symbol name->symbol modifiers.

Definition at line 56634 of file fortranscanner.cpp.

QList<Entry> moduleProcedures

static

Definition at line 56603 of file fortranscanner.cpp.

MethodTypes mtype

static

Definition at line 56609 of file fortranscanner.cpp.

Argument* parameter

static

Definition at line 56615 of file fortranscanner.cpp.

bool parsingPrototype = FALSE

static

Definition at line 56629 of file fortranscanner.cpp.

QCString result

static

Definition at line 56614 of file fortranscanner.cpp.

char stringStartSymbol

static

Definition at line 56628 of file fortranscanner.cpp.

QList<Entry> subrCurrent

static

Definition at line 56580 of file fortranscanner.cpp.

int typeMode = false

static

Definition at line 56624 of file fortranscanner.cpp.

Protection typeProtection

static

Definition at line 56623 of file fortranscanner.cpp.

QCString useModuleName

static

Definition at line 56621 of file fortranscanner.cpp.

ScanVar v_type = V_IGNORE

static

Definition at line 56602 of file fortranscanner.cpp.

Specifier virt

static

Definition at line 56611 of file fortranscanner.cpp.

yyconst flex_int16_t yy_accept[24249]

static

Definition at line 1077 of file fortranscanner.cpp.

yyconst flex_int16_t yy_acclist[6178]

static

Definition at line 394 of file fortranscanner.cpp.

register int yy_act

Definition at line 56936 of file fortranscanner.cpp.

yyconst flex_int32_t yy_base[29670]

static

Definition at line 3792 of file fortranscanner.cpp.

register char * yy_bp

Definition at line 56935 of file fortranscanner.cpp.

YY_BUFFER_STATE* yy_buffer_stack = 0

static

Stack as an array.

Definition at line 274 of file fortranscanner.cpp.

size_t yy_buffer_stack_max = 0

static

capacity of stack.

Definition at line 273 of file fortranscanner.cpp.

size_t yy_buffer_stack_top = 0

static

index of top of stack.

Definition at line 272 of file fortranscanner.cpp.

char* yy_c_buf_p = (char *) 0

static

Definition at line 297 of file fortranscanner.cpp.

yyconst flex_int16_t yy_chk[209459]

static

Definition at line 33370 of file fortranscanner.cpp.

register char* yy_cp

Definition at line 56935 of file fortranscanner.cpp.

YY_DECL

Initial value:

{
        register yy_state_type yy_current_state

The main scanner function which does all the work.

Definition at line 56933 of file fortranscanner.cpp.

yyconst flex_int16_t yy_def[29670]

static

Definition at line 7059 of file fortranscanner.cpp.

int yy_did_buffer_switch_on_eof

static

Definition at line 304 of file fortranscanner.cpp.

yyconst flex_int32_t yy_ec[256]

static

Definition at line 3748 of file fortranscanner.cpp.

int yy_full_lp

static

Definition at line 56421 of file fortranscanner.cpp.

char* yy_full_match

static

Definition at line 56418 of file fortranscanner.cpp.

int* yy_full_state

static

Definition at line 56422 of file fortranscanner.cpp.

char yy_hold_char

static

Definition at line 292 of file fortranscanner.cpp.

int yy_init = 0

static

Definition at line 298 of file fortranscanner.cpp.

int yy_looking_for_trail_begin = 0

static

Definition at line 56420 of file fortranscanner.cpp.

int yy_lp

static

Definition at line 56419 of file fortranscanner.cpp.

yyconst flex_int32_t yy_meta[72]

static

Initial value:

=
    {   0,
        1,    2,    3,    4,    1,    5,    1,    6,    7,    1,
        8,    1,    1,    9,   10,    1,   11,    1,   11,   12,
       12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
       12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
       12,   12,   12,    1,    1,    1,   12,   12,   12,   12,
       12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
       12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
        7
    }

Definition at line 3780 of file fortranscanner.cpp.

int yy_n_chars

static

Definition at line 293 of file fortranscanner.cpp.

yyconst flex_int16_t yy_nxt[209459]

static

Definition at line 10326 of file fortranscanner.cpp.

int yy_start = 0

static

Definition at line 299 of file fortranscanner.cpp.

int* yy_start_stack = NULL

static

Definition at line 56824 of file fortranscanner.cpp.

int yy_start_stack_depth = 0

static

Definition at line 56823 of file fortranscanner.cpp.

int yy_start_stack_ptr = 0

static

Definition at line 56822 of file fortranscanner.cpp.

yy_state_type* yy_state_buf =0

static

Definition at line 56417 of file fortranscanner.cpp.

yy_state_type * yy_state_ptr =0

static

Definition at line 56417 of file fortranscanner.cpp.

int yyColNr = 0

static

Definition at line 56596 of file fortranscanner.cpp.

QCString yyFileName

static

Definition at line 56594 of file fortranscanner.cpp.

int yyLineNr = 1

static

Definition at line 56595 of file fortranscanner.cpp.