proc.c

变尺度法的源程序

		break;
	case FPPLINE:
		fpp_line(lmode);
		outfl--;
		return;
		break;
	default:	
		fppmess(ERR_FPP);
		break;
	}

exit:	tokp = skipnl(tokp);
	outfl--;

	/* Output newline */
	outtok(tokp);
	return;
}

/************************************************************** Process */

void 
process() {
	InFile	*tmpf;
	Token   *tokp;

	for (;;) {
	        if (st_is(ST_NL)) {
			line_width = line_width0;
			if (falselvl) line_width = LINE_WIDTH_MAX;
			tokp = get_token_nl(mmode);
		}
		else 
			tokp = get_token(mmode);

		switch (tokp->val) {
		case TK_NL:
		        if (tokp->token[0] == '\n') {
			        outtok(tokp);
				break;
			}

		        /* Output all remaining comments */
		        if (comments && !outfl && !falselvl) {
			        for (;comments;) {
				        Comment *prev;

					outcomm(comments);
					prev = comments;
					comments = comments->next;
					free(prev);
				}
			}

			/* Adjust output if needed */
			if (ocolm != 0) {
			        my_fwrite("\n",1);
				oline++; ocolm = 0;
			}

			while (curif != curfile->ifnode) {
				fppmess(ERR_NOEND,curif->ifline);
				fpp_endif();
			}
			if (sbfl) sb_flush_ids(1);

			if (curfile->popfile) {
				tmpf = curfile;
				curfile = curfile->popfile;
				my_fclose(tmpf);
				curbuf = curfile->inbuf;
				curp = curbuf->psaved;
				include_path.str = curfile->dir;
				line = curfile->line;
				colm = 0;
			}
			else 	{
				my_fclose(curfile);
				curfile = NULL;
				my_fclose(outfile);
				outfile = NULL;
				return;
			}
			outpos(line, POPINCL);
			break;
		case TK_FPP: 
			if (st_is(ST_FPP)) {

			        /* Output comments if any */
			        if (comments) {
				        for (;comments;) {
					        Comment *prev;

						outcomm(comments);
						prev = comments;
						comments = comments->next;
						free(prev);
					}
				}
				directive();
			}
			else {
			        outtok(tokp);
			}
			break;
		default: 
		        outtok(tokp);
			break;
		}
	}
}

/************************************************************** Init */

StrList *include_path_last = &include_path;

int
add_path(char *p) {

	include_path_last->next = my_alloc(1,sizeof(StrList));
	include_path_last = include_path_last->next;
	include_path_last->str = my_strdup(p);
	return 0;
}

void
add_name(char *name, char *val) {
	SymPtr	sym;
	char	locbuf[BUFSIZE];
	char	*s;
	int	len;

	if (mmode & MOD_LCASE)
		tolowcase(name);
	sym = symget(name,CL_NM|CL_KEY|CL_FOP);        /* it does like fpp_define */
	if (sym && (symtype(sym) & (CL_KEY|CL_FOP))) {
		fppmess(WARN_DUBL1,name);
		sym = NULL;
	}
	locbuf[0]='b';		
	len = strlen(val);
	strcpy(locbuf+1,val);
	locbuf[1+len] = -1;
	locbuf[2+len] = '\0';
	s = my_strdup(locbuf);
	*s = '\0';
	s += len+2;
	if (sym) {
		char *d0 = symvals(sym) - 1;
		char *d1 = s - 1;

		do {
			if (*d0 != *d1) {
				fppmess(WARN_DUBL,name);
				break;
			}
		}
		while (*d0-- && *d1--);
		symsetvals(sym,s);
	}
	else {
		symsetnm(name,s);
	}
}

void
add_defs(StrList *defs) {
	StrList	*prev, *cur, *next;
	char	*name, *val;

	if (predefinefl) {
#ifdef sun
	add_name("sun","1");
#endif
#ifdef sparc
	add_name("sparc","1");
#endif
#ifdef unix
	add_name("unix","1");
#endif
	}

	cur = defs; prev = NULL;		/* list reverse */
	while (cur){ 		
		next = cur->next;
		cur->next = prev;
		prev = cur;
		cur = next;
	}
	cur = prev;
	while (cur) {
		name = cur->str;
		val = strchr(name,'=');
		if (val) {
			*val++ = 0;
			add_name(name,val);
		}
		else {
			add_name(name,"1");
		}
		prev = cur;
		cur = cur->next;
		free (prev);
	}
}

void
add_undefs(StrList *undefs) {
	StrList	*prev, *cur, *next;

	cur = undefs; prev = NULL;		/* list reverse */
	while (cur){ 		
		next = cur->next;
		cur->next = prev;
		prev = cur;
		cur = next;
	}
	cur = prev;
	while (cur) {
		if (mmode & MOD_LCASE)
			tolowcase(cur->str);
		symdel(cur->str);
		prev = cur;
		cur = cur->next;
		free (prev);
	}
}

void init_fpp();
void init_fop();
void init77();
void init90();

void
init1(char *fin, char *fout, StrList *defs, StrList *undefs) {
	char	*s;

	if ( mdepfl && fin == NULL ) 
		fppmess(FERR_MWOFN);
	if ( mdepfl && sbfl )
		sbfl = 0;
	if ( sbfl && linefl )
		linefl = 0;

	if (fin != NULL) { 
		s = fin;
		while (*s) s++;
		while (s!=fin && *s!='.') s--;
		if (*s=='.') {
			if (!strcmp(s,F77EXTENSION)) {
				if (f77fl == -1) 
					f77fl = 1;
			}
		}
	}
	if (f77fl == -1) 
		f77fl = 0;
	if (f77fl) {
		fixedformfl = 1;
		/* linefl = !linefl;	*/
	}
	else {
		if (fixedformfl == -1)
			fixedformfl = 0;
		/* linefl = linefl;  for symmetry */ 
	}

	/* Set extended line width for free form
	 * and then set output line width to be
	 * equal to that of input whatever it is
	 */
	if (!fixedformfl) {
		line_width0 = LINE_WIDTH_EXT;
	}
	oline_width = line_width0;

	if (!fixedformfl) {
		mmode &= ~MOD_SPACE;
	}
	linefl = !linefl;

	init_fpp();
	init_fop();
	if (f77fl) {
		init77();
		st_init(0);
	}
	else if (fixedformfl) {
		init90();
		st_init(1);
	}
	else {
		init90();
		st_init(2);
	}
	add_defs(defs);
	add_undefs(undefs);

	if (fin == NULL) { 
		curfile = fopen_stdfile(stdin);
	}
	else {
		curfile = my_fopen(fin,"r");
	}
	if (fout == NULL) { 
		outfile = fopen_stdfile(stdout);
	}
	else {
		outfile = my_fopen(fout,"w");
	}

	if ( mdepfl ) {
		char	*t;

		mfile = outfile;
		outfile = my_fopen("/dev/null","w");
		mdfname = my_strdup(curfile->fname);
		t = strrchr(mdfname,'.');
		*t = '\0';
		md_fwrite(fin);
	}

	line = 1;
	colm = 0;
	curfile->ifnode = NULL;
	include_path.str = curfile->dir;
	curbuf = curfile->inbuf;
	curp = INBUF_BEG(curbuf);
	curif = NULL;
	outfl = 0;
	falselvl = 0;
 	outpos(1, PUSHINCL);	
}

void
init0() {
	char	*s;

/*	mmode = MOD_CONT | MOD_LCASE;	*/
	mmode = MOD_CONT; 		/* now case-sensitive by default */
	line_width0 = LINE_WIDTH_STD;
	f77fl = -1;
	fixedformfl = -1;
	linefl = 0;
	sbfl = 0;
	predefinefl = 1;
	substfl = 2;                    /* by default, macros are expanded everywhere */
	rmcommfl = 0;
	mdepfl = 0;
	onequalsym = NULL;
	ctrl_mode = 0;                  /* don't process control chars */
	curfile = my_alloc(sizeof(InFile),1);
	curfile->fname = my_strdup("fpp");
	inactive = 0;

	s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_$";
	while (*s) chars[*s++] |= S_AL;
	s = "0123456789";
	while (*s) chars[*s++] |= S_NM;
	s = " \t\v\f\r";
	while (*s) chars[*s++] |= S_BL;
}

void
init_fpp() {
	static	char dyn[2] = {FPPDYNMACRO,0};

	symsetkw("#DEFINE",	FPPDEF		,CL_FPP);
	symsetkw("#UNDEF",	FPPUNDEF	,CL_FPP);
	symsetkw("#INCLUDE",	FPPINCL		,CL_FPP);
	symsetkw("#IF",		FPPIF		,CL_FPP);
	symsetkw("#ELIF",	FPPELIF		,CL_FPP);
	symsetkw("#ELSE",	FPPELSE		,CL_FPP);
	symsetkw("#ENDIF",	FPPENDIF	,CL_FPP);
	symsetkw("#IFDEF",	FPPIFDEF	,CL_FPP);
	symsetkw("#IFNDEF",	FPPIFNDEF	,CL_FPP);
	symsetkw("#LINE",	FPPLINE		,CL_FPP);

	symsetkw("__FILE__",	0	,CL_NM);
	symsetkw("__LINE__",	0	,CL_NM);

	filesymp = symget("__file__", CL_NM);
	CHECK(filesymp);
	FILEsymp = symget("__FILE__", CL_NM);
	if (FILEsymp == NULL) 
		FILEsymp = filesymp;
	symsetvals( filesymp, dyn);
	symsetvals( FILEsymp, dyn);
	linesymp = symget("__line__", CL_NM);
	CHECK(linesymp);
	LINEsymp = symget("__LINE__", CL_NM);
	if (LINEsymp == NULL) 
		LINEsymp = linesymp;
	symsetvals( linesymp, dyn);
	symsetvals( LINEsymp, dyn);
}

void
init_fop() {
	symsetkw("TRUE",	FTN_TRUE	,CL_FOP);
	symsetkw("FALSE",	FTN_FALSE	,CL_FOP);
	symsetkw("EQ",		FTN_EQ		,CL_FOP);
	symsetkw("NE",		FTN_NE		,CL_FOP);
	symsetkw("LT",		FTN_LT		,CL_FOP);
	symsetkw("LE",		FTN_LE		,CL_FOP);
	symsetkw("GT",		FTN_GT		,CL_FOP);
	symsetkw("GE",		FTN_GE		,CL_FOP);
	symsetkw("AND",		FTN_AND		,CL_FOP);
	symsetkw("OR",		FTN_OR		,CL_FOP);
	symsetkw("NEQV",	FTN_NEQV	,CL_FOP);
	symsetkw("XOR",		FTN_XOR		,CL_FOP);
	symsetkw("EQV",		FTN_EQV		,CL_FOP);
	symsetkw("NOT",		FTN_NOT		,CL_FOP);
	symsetkw("PRAGMA",	FTN_PRAGMA	,CL_FOP);
}

void
init77() {
	symsetkw("ACCEPT",	FTN_ACCEPT	,CL_KEY);
	symsetkw("ASSIGN",	FTN_ASSIGN	,CL_KEY);
	symsetkw("TO",		FTN_TO		,CL_FOP);
	symsetkw("AUTOMATIC",	FTN_AUTOMATIC	,CL_KEY);
	symsetkw("BACKSPACE",	FTN_BACKSPACE	,CL_KEY);
	symsetkw("BLOCKDATA",	FTN_BLOCKDATA	,CL_KEY);
	symsetkw("DATA",	FTN_DATA	,CL_KEY);
	symsetkw("BYTE",	FTN_BYTE	,CL_KEY);
	symsetkw("CALL",	FTN_CALL	,CL_KEY);
	symsetkw("CHARACTER",	FTN_CHARACTER	,CL_KEY);
	symsetkw("CLOSE",	FTN_CLOSE	,CL_KEY);
	symsetkw("COMMON",	FTN_COMMON	,CL_KEY);
	symsetkw("COMPLEX",	FTN_COMPLEX	,CL_KEY);
	symsetkw("CONTINUE",	FTN_CONTINUE	,CL_KEY);
	symsetkw("DECODE",	FTN_DECODE	,CL_KEY);
	symsetkw("DIMENSION",	FTN_DIMENSION	,CL_KEY);
	symsetkw("DO",		FTN_DO		,CL_KEY);
	symsetkw("DOWHILE",	FTN_DOWHILE	,CL_KEY);
	symsetkw("DOUBLECOMPLEX",	FTN_DOUBLECOMP	,CL_KEY); 
	symsetkw("DOUBLEPRECISION",	FTN_DOUBLEPREC	,CL_KEY);
	symsetkw("ELSE",	FTN_ELSE	,CL_KEY);
	symsetkw("ELSEIF",	FTN_ELSEIF	,CL_KEY);
	symsetkw("END",		FTN_END		,CL_KEY);
	symsetkw("ENDDO",	FTN_ENDDO	,CL_KEY);
	symsetkw("ENDFILE",	FTN_ENDFILE	,CL_KEY);
	symsetkw("ENDIF",	FTN_ENDIF	,CL_KEY);
	symsetkw("ENDMAP",	FTN_ENDMAP	,CL_KEY);
	symsetkw("ENDSTRUCTURE",FTN_ENDSTRUCTURE,CL_KEY);
	symsetkw("ENDUNION",	FTN_ENDUNION	,CL_KEY);
	symsetkw("ENCODE",	FTN_ENCODE	,CL_KEY);
	symsetkw("ENTRY",	FTN_ENTRY	,CL_KEY);
	symsetkw("EQUIVALENCE",	FTN_EQUIVALENCE	,CL_KEY);
	symsetkw("EXTERNAL",	FTN_EXTERNAL	,CL_KEY);
	symsetkw("FORMAT",	FTN_FORMAT	,CL_KEY);
	symsetkw("FUNCTION",	FTN_FUNCTION	,CL_KEY);
	symsetkw("GOTO",	FTN_GOTO	,CL_KEY);
	symsetkw("IF",		FTN_IF		,CL_KEY);
	symsetkw("IMPLICIT",	FTN_IMPLICIT	,CL_KEY);
	symsetkw("INCLUDE",	FTN_INCLUDE	,CL_KEY); 
	symsetkw("INQUIRE",	FTN_INQUIRE	,CL_KEY);
	symsetkw("INTEGER",	FTN_INTEGER	,CL_KEY);
	symsetkw("INTRINSIC",	FTN_INTRINSIC	,CL_KEY);
	symsetkw("LOGICAL",	FTN_LOGICAL	,CL_KEY);
	symsetkw("MAP",		FTN_MAP		,CL_KEY);
	symsetkw("NAMELIST",	FTN_NAMELIST	,CL_KEY);
	symsetkw("OPEN",	FTN_OPEN	,CL_KEY);
	symsetkw("OPTIONS",	FTN_OPTIONS	,CL_KEY);
	symsetkw("PARAMETER",	FTN_PARAMETER	,CL_KEY);
	symsetkw("PAUSE",	FTN_PAUSE	,CL_KEY);
	symsetkw("POINTER",	FTN_POINTER	,CL_KEY);
	symsetkw("PROGRAM",	FTN_PROGRAM	,CL_KEY);
	symsetkw("PRINT",	FTN_PRINT	,CL_KEY);
	symsetkw("READ",	FTN_READ	,CL_KEY);
	symsetkw("REAL",	FTN_REAL	,CL_KEY);
	symsetkw("RECORD",	FTN_RECORD	,CL_KEY);
	symsetkw("RETURN",	FTN_RETURN	,CL_KEY);
	symsetkw("REWIND",	FTN_REWIND	,CL_KEY);
	symsetkw("SAVE",	FTN_SAVE	,CL_KEY);
	symsetkw("STATIC",	FTN_STATIC	,CL_KEY);
	symsetkw("STOP",	FTN_STOP	,CL_KEY);
	symsetkw("STRUCTURE",	FTN_STRUCTURE	,CL_KEY);
	symsetkw("SUBROUTINE",	FTN_SUBROUTINE	,CL_KEY);
	symsetkw("TYPE",	FTN77_FST+63	,CL_KEY);
	symsetkw("UNION",	FTN_UNION	,CL_KEY);
	symsetkw("VIRTUAL",	FTN_VIRTUAL	,CL_KEY);
	symsetkw("VOLATILE",	FTN_VOLATILE	,CL_KEY);
	symsetkw("WRITE",	FTN_WRITE	,CL_KEY);

	symsetkw("UNIT",	FTN77_FST+100	,CL_KEY);
	symsetkw("FILE",	FTN77_FST+101	,CL_KEY);
	symsetkw("ACCESS",	FTN77_FST+102	,CL_KEY);
	symsetkw("BLANK",	FTN77_FST+103	,CL_KEY);
	symsetkw("ERR",		FTN77_FST+104	,CL_KEY);
	symsetkw("FORM",	FTN77_FST+105	,CL_KEY);
	symsetkw("IOSTAT",	FTN77_FST+106	,CL_KEY);
	symsetkw("RECL",	FTN77_FST+107	,CL_KEY);
	symsetkw("STATUS",	FTN77_FST+108	,CL_KEY);
	symsetkw("FILEOPT",	FTN77_FST+109	,CL_KEY);
	symsetkw("FMT",		FTN77_FST+110	,CL_KEY);
	symsetkw("REC",		FTN77_FST+111	,CL_KEY);
	symsetkw("NML",		FTN77_FST+112	,CL_KEY);
	symsetkw("EXIST",	FTN77_FST+113	,CL_KEY);
	symsetkw("OPENED",	FTN77_FST+114	,CL_KEY);
	symsetkw("NAMED",	FTN77_FST+115	,CL_KEY);
	symsetkw("ACCESS",	FTN77_FST+116	,CL_KEY);
	symsetkw("SEQUENTIAL",	FTN77_FST+117	,CL_KEY);
	symsetkw("DIRECT",	FTN77_FST+118	,CL_KEY);
	symsetkw("FORM",	FTN77_FST+119	,CL_KEY);
	symsetkw("FORMATTED",	FTN77_FST+120	,CL_KEY);
	symsetkw("UNFORMATTED",	FTN77_FST+121	,CL_KEY);
	symsetkw("NAME",	FTN77_FST+122	,CL_KEY);
	symsetkw("OSTAT",	FTN77_FST+123	,CL_KEY);
	symsetkw("NUMBER",	FTN77_FST+124	,CL_KEY);
	symsetkw("NEXTREC",	FTN77_FST+125	,CL_KEY);

	symsetkw("DOUBLE",	FTN77_FST+126	,CL_FOP);
	symsetkw("PRECISION",	FTN77_FST+127	,CL_FOP);
	symsetkw("BLOCK",	FTN77_FST+128	,CL_FOP);
	symsetkw("WHILE",	FTN77_FST+129	,CL_FOP);
}

void
init90() {
	symsetkw("INCLUDE",	FTN90_FST	,CL_KEY);
	symsetkw("TYPE",	FTN_TYPE	,CL_KEY);
	symsetkw("PRIVATE",	FTN90_FST+2	,CL_KEY);
	symsetkw("SEQUENCE",	FTN90_FST+3	,CL_KEY);
	symsetkw("ENDTYPE",	FTN90_FST+4	,CL_KEY);
	symsetkw("POINTER",	FTN90_FST+5	,CL_KEY);
	symsetkw("DIMENSION",	FTN90_FST+6	,CL_KEY);
	symsetkw("INTEGER",	FTN_INTEGER	,CL_KEY);
	symsetkw("REAL",	FTN_REAL	,CL_KEY);
	symsetkw("DOUBLEPRECISION", FTN_DOUBLEPREC ,CL_KEY);
	symsetkw("COMPLEX",	FTN_COMPLEX	,CL_KEY);
	symsetkw("CHARACTER",	FTN_CHARACTER	,CL_KEY);
	symsetkw("LOGICAL",	FTN_LOGICAL	,CL_KEY);
	symsetkw("PARAMETER",	FTN90_FST+13	,CL_KEY);
	symsetkw("ALLOCATABLE",	FTN90_FST+14	,CL_KEY);
	symsetkw("EXTERNAL",	FTN90_FST+15	,CL_KEY);
	symsetkw("INTENT",	FTN90_FST+16	,CL_KEY);
	symsetkw("INTRINSIC",	FTN90_FST+17	,CL_KEY);
	symsetkw("OPTIONAL",	FTN90_FST+18	,CL_KEY);
	symsetkw("SAVE",	FTN90_FST+19	,CL_KEY);
	symsetkw("TARGET",	FTN90_FST+20	,CL_KEY);
	symsetkw("PUBLIC",	FTN90_FST+21	,CL_KEY);
	symsetkw("IN",		FTN90_FST+22	,CL_FOP);
	symsetkw("OUT",		FTN90_FST+23	,CL_FOP);
	symsetkw("INOUT",	FTN90_FST+24	,CL_FOP);
	symsetkw("OPTIONAL",	FTN90_FST+25	,CL_KEY);
	symsetkw("DATA",	FTN90_FST+26	,CL_KEY);
	symsetkw("IMPLICIT",	FTN_IMPLICIT	,CL_KEY);
	symsetkw("IMPLICITNONE",FTN90_FST+28	,CL_KEY);
	symsetkw("NAMELIST",	FTN90_FST+29	,CL_KEY);
	symsetkw("EQUIVALENCE",	FTN90_FST+30	,CL_KEY);
	symsetkw("COMMON",	FTN90_FST+31	,CL_KEY);
	symsetkw("ALLOCATE",	FTN90_FST+32	,CL_KEY);
	symsetkw("STAT",	FTN90_FST+33	,CL_FOP);
	symsetkw("NULLIFY",	FTN90_FST+34	,CL_KEY);
	symsetkw("DEALLOCATE",	FTN90_FST+35	,CL_KEY);
	symsetkw("WHERE",	FTN90_FST+36	,CL_KEY);
	symsetkw("ELSEWHERE",	FTN90_FST+37	,CL_KEY);
	symsetkw("ENDWHERE",	FTN90_FST+38	,CL_KEY);
	symsetkw("IF",		FTN90_FST+39	,CL_KEY);
	symsetkw("THEN",	FTN90_FST+40	,CL_KEY);
	symsetkw("ELSE",	FTN90_FST+41	,CL_KEY);
	symsetkw("ELSEIF",	FTN90_FST+42	,CL_KEY);
	symsetkw("ENDIF",	FTN90_FST+43	,CL_KEY);
	symsetkw("SELECTCASE",	FTN90_FST+44	,CL_KEY);
	symsetkw("CASE",	FTN90_FST+45	,CL_KEY);
	symsetkw("ENDSELECT",	FTN90_FST+46	,CL_KEY);
	symsetkw("DEFAULT",	FTN90_FST+47	,CL_KEY);
	symsetkw("DO",		FTN_DO		,CL_KEY);
	symsetkw("WHILE",	FTN90_FST+49	,CL_KEY);
	symsetkw("ENDDO",	FTN90_FST+50	,CL_KEY);
	symsetkw("CYCLE",	FTN90_FST+51	,CL_KEY);
	symsetkw("EXIT",	FTN90_FST+52	,CL_KEY);
	symsetkw("GOTO",	FTN90_FST+53	,CL_KEY);
	symsetkw("ASSIGN",	FTN_ASSIGN	,CL_KEY);
	symsetkw("TO",		FTN90_FST+55	,CL_FOP);
	symsetkw("CONTINUE",	FTN90_FST+56	,CL_KEY);
	symsetkw("STOP",	FTN90_FST+57	,CL_KEY);
	symsetkw("PAUSE",	FTN90_FST+58	,CL_KEY);
	symsetkw("OPEN",	FTN90_FST+59	,CL_KEY);
	symsetkw("CLOSE",	FTN90_FST+60	,CL_KEY);
	symsetkw("READ",	FTN_READ	,CL_KEY);
	symsetkw("WRITE",	FTN_WRITE	,CL_KEY);
	symsetkw("PRINT",	FTN90_FST+63	,CL_KEY);
	symsetkw("BACKSPACE",	FTN90_FST+64	,CL_KEY);
	symsetkw("ENDFILE",	FTN90_FST+65	,CL_KEY);
	symsetkw("REWIND",	FTN90_FST+66	,CL_KEY);
	symsetkw("INQUIRE",	FTN90_FST+67	,CL_KEY);
	symsetkw("FORMAT",	FTN_FORMAT	,CL_KEY);
	symsetkw("PROGRAM",	FTN90_FST+69	,CL_KEY);
	symsetkw("ENDPROGRAM",	FTN90_FST+70	,CL_KEY);
	symsetkw("MODULE",	FTN90_FST+71	,CL_KEY);
	symsetkw("ENDMODULE",	FTN90_FST+72	,CL_KEY);
	symsetkw("END",		FTN90_FST+73	,CL_KEY);
	symsetkw("USE",		FTN90_FST+74	,CL_KEY);
	symsetkw("ONLY",	FTN90_FST+75	,CL_FOP);
	symsetkw("BLOCKDATA",	FTN90_FST+76	,CL_KEY);
	symsetkw("ENDBLOCKDATA",FTN90_FST+77	,CL_KEY);
	symsetkw("INTERFACE",	FTN90_FST+78	,CL_KEY);
	symsetkw("ENDINTERFACE",FTN90_FST+79	,CL_KEY);
	symsetkw("MODULEPROCEDURE",FTN90_FST+80	,CL_KEY);
	symsetkw("OPERATOR",	FTN90_FST+81	,CL_KEY);
	symsetkw("ASSIGNMENT",	FTN90_FST+82	,CL_KEY);
	symsetkw("CALL",	FTN90_FST+83	,CL_KEY);
	symsetkw("FUNCTION",	FTN90_FST+84	,CL_KEY);
	symsetkw("RESULT",	FTN90_FST+85	,CL_FOP);
	symsetkw("RECURSIVE",	FTN90_FST+86	,CL_KEY);
	symsetkw("ENDFUNCTION",	FTN90_FST+87	,CL_KEY);
	symsetkw("SUBROUTINE",	FTN90_FST+88	,CL_KEY);
	symsetkw("ENDSUBROUTINE", FTN90_FST+89	,CL_KEY);
	symsetkw("ENTRY",	FTN90_FST+90	,CL_KEY);
	symsetkw("RETURN",	FTN90_FST+91	,CL_KEY);
	symsetkw("CONTAINS",	FTN90_FST+92	,CL_KEY);

	symsetkw("KIND",	FTN90_FST+93	,CL_FOP);
	symsetkw("LEN",		FTN90_FST+94	,CL_FOP);

	symsetkw("UNIT",	FTN90_FST+95	,CL_FOP);
	symsetkw("IOSTAT",	FTN90_FST+96	,CL_FOP);
	symsetkw("ERR",		FTN90_FST+97	,CL_FOP);
	symsetkw("FILE",	FTN90_FST+98	,CL_FOP);
	symsetkw("STATUS",	FTN90_FST+99	,CL_FOP);
	symsetkw("ACCESS",	FTN90_FST+100	,CL_FOP);
	symsetkw("FORM",	FTN90_FST+101	,CL_FOP);
	symsetkw("RECL",	FTN90_FST+102	,CL_FOP);
	symsetkw("BLANK",	FTN90_FST+103	,CL_FOP);
	symsetkw("POSITION",	FTN90_FST+104	,CL_FOP);
	symsetkw("ACTION",	FTN90_FST+105	,CL_FOP);
	symsetkw("DELIM",	FTN90_FST+106	,CL_FOP);
	symsetkw("PAD",		FTN90_FST+107	,CL_FOP);
	symsetkw("FMT",		FTN90_FST+108	,CL_FOP);
	symsetkw("NML",		FTN90_FST+109	,CL_FOP);
	symsetkw("REC",		FTN90_FST+110	,CL_FOP);
	symsetkw("ADVANCE",	FTN90_FST+111	,CL_FOP);
	symsetkw("SIZE",	FTN90_FST+112	,CL_FOP);
	symsetkw("EOR",		FTN90_FST+113	,CL_FOP);
	symsetkw("EXIST",	FTN90_FST+114	,CL_FOP);
	symsetkw("OPENED",	FTN90_FST+115	,CL_FOP);
	symsetkw("NUMBER",	FTN90_FST+116	,CL_FOP);
	symsetkw("NAMED",	FTN90_FST+117	,CL_FOP);
	symsetkw("NAME",	FTN90_FST+118	,CL_FOP);
	symsetkw("SEQUENTIAL",	FTN90_FST+119	,CL_FOP);
	symsetkw("DIRECT",	FTN90_FST+120	,CL_FOP);
	symsetkw("FORMATTED",	FTN90_FST+121	,CL_FOP);
	symsetkw("UNFORMATTED",	FTN90_FST+122	,CL_FOP);
	symsetkw("NEXTREC",	FTN90_FST+123	,CL_FOP);
	symsetkw("READWRITE",	FTN90_FST+124	,CL_FOP);

	symsetkw("NONE",	FTN90_FST+125	,CL_FOP);
	symsetkw("DOUBLE",	FTN90_FST+126	,CL_FOP);
	symsetkw("PRECISION",	FTN90_FST+127	,CL_FOP);
	symsetkw("SELECT",	FTN90_FST+128	,CL_FOP);
	symsetkw("PROCEDURE",	FTN90_FST+129	,CL_FOP);
	symsetkw("BLOCK",	FTN90_FST+130	,CL_FOP);
	
}