cobol.scan

这是一个Linux下的集成开发环境

					xxError, Attribute.Position);
      					error_count ++;
				     }
				     Attribute.Position = start_position;
				     Attribute.string.Value = PutString (String, length);
				     yyPrevious; return string; }

#String1# - {'\t\r\n} +		:- { if (length < MaxStringLength) length += GetWord (& String [length]); }
#String1# \'\'			:- { if (length < MaxStringLength) length += GetWord (& String [length]); }
#String1# \t			:- { if (length < MaxStringLength) String [length ++] = '\t'; }
#String1# \r			:- {}
#String1# \'			:- { lString1: if (length < MaxStringLength)
				     (void) strcpy (& String [length ++], "\'");
				     Attribute.string.Value = PutString (String, length);
				     yyPrevious; return string; }

#STD#	  \"			:  { yyStart (String2); length = 1; String [0] = '\"';
				     start_position = Attribute.Position; }

#String2# \" " " * EOL / "-" " " * \"
				:- { yyEol (0); if (free_format) goto lString2; }
#String2# < "-" " " * \"	:- {}
#String2# < ANY " " * / - {\ "\n} ANY *,
#String2# < ANY " " * \"	:  { if (! in_comment_entry) {
					Message ("continuation of string expected",
					xxError, Attribute.Position);
      					error_count ++;
				     }
				     Attribute.Position = start_position;
				     Attribute.string.Value = PutString (String, length);
				     yyPrevious; return string; }

#String2# - {"\t\r\n} +		:- { if (length < MaxStringLength) length += GetWord (& String [length]); }
#String2# \"\"			:- { if (length < MaxStringLength) length += GetWord (& String [length]); }
#String2# \t			:- { if (length < MaxStringLength) String [length ++] = '\t'; }
#String2# \r			:- {}
#String2# \"			:- { lString2: if (length < MaxStringLength)
				     (void) strcpy (& String [length ++], "\"");
				     Attribute.string.Value = PutString (String, length);
				     yyPrevious; return string; }

					/* handle picture string	*/

#STD# P I C (T U R E) ?		: { length = GetUpper (String);
				    Attribute.name.Ident = MakeIdent (String, length);
				    if (! (keywords [Attribute.name.Ident].mask & dialect))
				       return name;
				    if (hl)
				       (void) fprintf (hlfp, "%d key %d.%d %d.%d\n", PAF_HIGH,
				       Attribute.Position.Line, Attribute.Position.Column - 1,
				       Attribute.Position.Line, Attribute.Position.Column + TokenLength - 1);
				    yyStart (Picture); return PICTURE; }

#Picture# I S			: { if (hl)
				       (void) fprintf (hlfp, "%d key %d.%d %d.%d\n", PAF_HIGH,
				       Attribute.Position.Line, Attribute.Position.Column - 1,
				       Attribute.Position.Line, Attribute.Position.Column + TokenLength - 1);
				    return IS; }

#Picture# (PicElmt | ".") * PicElmt,
#Picture# PicElmt + "." / "."	: { length = GetUpper (String);
				    Attribute.string.Value = PutString (String, length);
				    yyPrevious; CheckLength (TokenLength, 30); return string; }

#Picture# - {\ \t\n}		: { Attribute.string.Value = GetStringRef (NoIdent);
				    yyLess (0); yyPrevious; return string; }

					/* continuation of picture string	*/

#Picture# (PicElmt | ".") + / " " * EOL "-"
				: { length = GetUpper (String);
				    if (free_format) {
				       Attribute.string.Value = PutString (String, length);
				       CheckLength (TokenLength, 30);
				       yyPrevious; return string;
				    } else
				       yyStart (Continue_Picture); }

#Continue_Picture, Continue_Int, Continue_Real, Continue_Para, Continue_Name#
	" " * EOL "-" {\ \t} *	:- { yyEol ((TokenLength - 1 - (strchr (TokenPtr, '\n') - TokenPtr))); }


#Continue_Picture# (PicElmt | ".") * PicElmt,
#Continue_Picture# PicElmt + "." / "."
				:- { length += GetUpper (& String [length]);
				     Attribute.string.Value = PutString (String, length);
				     yyStart (STD); CheckLength (length, 30); return string; }

#Continue_Picture# - {\ \t\n}	:- { yyLess (0); yyStart (STD);
				     Attribute.string.Value = PutString (String, length);
				     CheckLength (length, 30);
				     return string; }

#STD# I N C L U D E		: { if (dialect != copy_replace) goto lCOPY;
				    Attribute.name.Ident =
				       MakeIdent (TokenPtr, TokenLength);
				    return name; }

#STD# C O P Y			: { lCOPY: Attribute.name.Ident = iCOPY;
				    if (! (keywords [Attribute.name.Ident].mask & dialect))
				       return name;
				    if (hl)
				       (void) fprintf (hlfp, "%d key %d.%d %d.%d\n", PAF_HIGH,
				       Attribute.Position.Line, Attribute.Position.Column - 1,
				       Attribute.Position.Line, Attribute.Position.Column + TokenLength - 1);
				    if (ansi_copy && ! in_comment_entry) (void) copy_pars ();
				    else return COPY; }

			/* next pattern should actually be '< "-INC" LUDE ?' */
#STD# "-INC" LUDE ?		,
#STD# "++INC" LUDE ?		:-{ yyStart (Include); }

#Include# (Letter | Digit) ((Letter | Digit | "-") * (Letter | Digit)) ?
				: { (void) Copy (MakeIdent (TokenPtr, TokenLength), Attribute.Position);
				    yyPrevious; }

#Include# \f | \r | \26		:-{}	/* skip control characters	*/

#Include# - {\ \t\r\n}		:-{ yyLess (0); yyPrevious; }

#STD# R E P L A C E		: { lREPLACE: Attribute.name.Ident = iREPLACE;
				    if (! (keywords [Attribute.name.Ident].mask & dialect))
				       return name;
				    if (hl)
				       (void) fprintf (hlfp, "%d key %d.%d %d.%d\n", PAF_HIGH,
				       Attribute.Position.Line, Attribute.Position.Column - 1,
				       Attribute.Position.Line, Attribute.Position.Column + TokenLength - 1);
				    if (ansi_copy && ! in_comment_entry) (void) copy_pars ();
				    else return REPLACE; }

#STD# E X E C (U T E) ? /* " " + (S Q L | C I C S | D L I) */
				: { if (hl)
				       (void) fprintf (hlfp, "%d key %d.%d %d.%d\n", PAF_HIGH,
				       Attribute.Position.Line, Attribute.Position.Column - 1,
				       Attribute.Position.Line, Attribute.Position.Column + TokenLength - 1);
				    yyStart (SQL); }

					/* delimiters			*/

#STD# "&"	: { return '&'	; }
#STD# "("	: { return '('	; }
#STD# ")"	: { return ')'	; }
#STD# "*"	: { return '*'	; }
#STD# "**"	: { return '**'	; }
#STD# "+"	: { return '+'	; }
#STD# "-"	: { return '-'	; }
#STD# "."	: { return '.'	; }
#STD# "/"	: { return '/'	; }
#STD# "66"	: { return '66'	; }
#STD# "77"	: { return '77'	; }
#STD# "78"	: { return '78'	; }
#STD# "88"	: { return '88'	; }
#STD# ":"	: { return ':'	; }
#STD# "<"	: { return '<'	; }
#STD# "<="	: { return '<='	; }
#STD# "<>"	: { return '<>'	; }
#STD# "="	: { return '='	; }
#STD# ">"	: { return '>'	; }
#STD# ">="	: { return '>='	; }
#STD# "=="	: { return '=='	; }

					/* numbers and names		*/

#STD# Digit +			: { int i = atol (TokenPtr);
				    CheckLength (TokenLength, 18);
				    if (1 <= i && i <= 49) {
				       Attribute.level_number.Value = i;
				       return level_number;
				    } else {
				       Attribute.unsigned_integer.Value = i;
				       return unsigned_integer;
				    }
				  }

#STD# "+" Digit +		: { Attribute.plus_integer.Value = atol (TokenPtr);
				    CheckLength (TokenLength, 19);
				    return plus_integer; }

#STD# "-" Digit +		: { Attribute.minus_integer.Value = atol (TokenPtr);
				    CheckLength (TokenLength, 19);
				    return minus_integer; }

#STD# {+\-} ? Digit * {.,} Digit + (E {+\-} ? Digit +) ?
				: { length = GetWord (String);
				    k = HandleContinuedNumber (length);
				    if (k >= 0) return k; }

#STD# {=Xx} \" HexDigit + \"	,
#STD# {=Xx} \' HexDigit + \'	: { Attribute.string.Value =
				       PutString (TokenPtr, TokenLength);
				    return string; }

#STD# Digit ((Digit | "-") * Digit) ?
				: { Attribute.paragraph_name.Ident =
				       MakeIdent (TokenPtr, TokenLength);
				    CheckLength (TokenLength, 30);
				    return paragraph_name; }

#STD# (Letter | Digit) ((Letter | Digit | "-") * (Letter | Digit)) ?
				: { lName: length = GetUpper (String);
				    Attribute.name.Ident = MakeIdent (String, length);
				    if (Attribute.name.Ident <= max_keyword &&
				       (keywords [Attribute.name.Ident].mask & dialect)) {
				       if (hl)
					  (void) fprintf (hlfp, "%d key %d.%d %d.%d\n", PAF_HIGH,
					  Attribute.Position.Line, Attribute.Position.Column - 1,
					  Attribute.Position.Line, Attribute.Position.Column + TokenLength - 1);
				       return keywords [Attribute.name.Ident].code;
				    }
				    CheckLength (TokenLength, 30);
				    return name; }

					/* continuation of numbers and names */

#STD# {+\-} ? Digit * / " " * EOL "-"
				:  { length = GetWord (String);
				     if (free_format)
				        return HandleContinuedNumber (length);
				     else
					yyStart (Continue_Int); }

#STD# {+\-} ? Digit * "." Digit * (E {+\-} ? Digit *) ? / " " * EOL "-"
				:  { length = GetWord (String);
				     if (decimal_point_is_comma)
				        return HandleContinuedNumber (length);
				     else if (free_format)
				        return HandleContinuedNumber (length);
				     else
					yyStart (Continue_Real); }

#STD# {+\-} ? Digit * "," Digit * (E {+\-} ? Digit *) ? / " " * EOL "-"
				:  { length = GetWord (String);
				     if (! decimal_point_is_comma) {
				        k = HandleContinuedNumber (length);
				        if (k >= 0) return k;
				     } else if (free_format)
				        return HandleContinuedNumber (length);
				     else
					yyStart (Continue_Real); }

#STD# Digit (Digit | "-") * / " " * EOL "-"
				:  { length = GetWord (String);
				     if (free_format) {
					Attribute.paragraph_name.Ident = MakeIdent (String, length);
					CheckLength (length, 30);
					yyPrevious; return paragraph_name;
				     } else
					yyStart (Continue_Para); }

#STD# (Letter | Digit) (Letter | Digit | "-") * / " " * EOL "-"
				:  { if (free_format) goto lName;
				     length = GetUpper (String);
				     yyStart (Continue_Name); }

#Continue_Int# Digit * ({.,} Digit + (E {+\-} ? Digit +) ?) ? ,
#Continue_Real# Digit * (E {+\-} ? Digit +) ? ,
#Continue_Real# {+\-} ? Digit +	:- { length += GetWord (& String [length]);
				     yyPrevious;
				     return HandleContinuedNumber (length); }

#Continue_Int, Continue_Para# (Digit | "-") * Digit
				:- { length += GetWord (& String [length]);
				     Attribute.paragraph_name.Ident = MakeIdent (String, length);
				     CheckLength (length, 30);
				     yyPrevious; return paragraph_name; }

#Continue_Int, Continue_Para, Continue_Name# (Letter | Digit | "-") * (Letter | Digit)
				:- { length += GetUpper (& String [length]);
				     yyPrevious;
				     Attribute.name.Ident = MakeIdent (String, length);
				     if (Attribute.name.Ident <= max_keyword &&
				        (keywords [Attribute.name.Ident].mask & dialect)) {
				        int token = keywords [Attribute.name.Ident].code;
					if (hl) (void) fprintf (hlfp, "%d key %d.%d %d.%d\n", PAF_HIGH,
					   Attribute.Position.Line, Attribute.Position.Column - 1,
					   yyLineCount, (unsigned char *) TokenPtr - yyLineStart + TokenLength - 1);
				        if (token == kCOPY || token == kREPLACE) {
					   if (ansi_copy && ! in_comment_entry) {
					      (void) copy_pars ();
					   } else {
					      return token;
					   }
				        } else if (token == kPICTURE) {
					   yyStart (Picture);
					   return token;
					} else {
					   return token;
					}
				     } else if (Attribute.name.Ident == iNOTE) {
					yyStart (Note);
				        start_position = Attribute.Position;
				     } else if (Attribute.name.Ident == iSKIP1 ||
					Attribute.name.Ident == iSKIP2 ||
					Attribute.name.Ident == iSKIP3) {
				     } else {
					CheckLength (length, 30);
					return name;
				     } }

#Continue_Int, Continue_Real# - {\ \t\n}
				:- { yyLess (0); yyPrevious;
				     return HandleContinuedNumber (length); }

#Continue_Name, Continue_Para# - {\ \t\n}
				:- { yyLess (0); yyPrevious;
				     Attribute.name.Ident = MakeIdent (String, length);
				     CheckLength (length, 30);
				     return name; }

#SQL# - {Ee\t\n} + | E		:- {}
#SQL# E N D "-" E X E C		: { if (hl)
				       (void) fprintf (hlfp, "%d key %d.%d %d.%d\n", PAF_HIGH,
				       Attribute.Position.Line, Attribute.Position.Column - 1,
				       Attribute.Position.Line, Attribute.Position.Column + TokenLength - 1);
				    yyPrevious; return EXECUTE; }

#Pseudo_Text# - {=\t\n} + | =	:- { if (length < MaxStringLength)
					length += GetWord (& String [length]); }
#Pseudo_Text# \t		:- { if (length < MaxStringLength)
					String [length ++] = '\t'; }
#Pseudo_Text# \n		:- { if (length < MaxStringLength)
					String [length ++] = '\n'; yyEol (0); }
#Pseudo_Text# ==		:- { Attribute.pseudo_text.Value =
					PutString (String, length);
				     Attribute.Position = start_position;
				     yyLess (0); yyPrevious;
				     return pseudo_text; }

#STD# {!#$%?@[\\]^_`{|\}~}	: { if (! in_comment_entry) {
				       Attribute.illegal_character.Value =
					  * TokenPtr;
				       return illegal_character;
				  } }

/*
#STD# (PicElmt | ".") * PicElmt,
#STD# PicElmt + "." / "."	: { length = GetUpper (String);
				    Attribute.string.Value = PutString (String, length);
				    CheckLength (TokenLength, 30); return string; }

#STD# (PicElmt | ".") + / " " * EOL "-"
				: { length = GetUpper (String);
				    yyStart (Continue_Picture); }
*/

					/* compiler directives		*/

#Directive# \n			: { yyEol (0); return EofToken; }

#Directive# \f | \r | \26	:-{}	/* skip control characters	*/

#Directive# Digit +		: { Attribute.unsigned_integer.Value =
					atol (TokenPtr);
				    return unsigned_integer; }

#Directive# \' - {'\n} * \'	,
#Directive# \" - {"\n} * \"	: { Attribute.string.Value =
					PutString (TokenPtr, TokenLength);
				    return string; }

#Directive# "<"	: { return 10; }
#Directive# "="	: { return 12; }
#Directive# ">"	: { return 11; }
#Directive# D E F I N E D	: { return 14; }
#Directive# D I S P L A Y	: { return 5; }
#Directive# E L S E	: { return 6; }
#Directive# E N D	: { return 7; }
#Directive# I F	: { return 9; }
#Directive# N O T	: { return 13; }
#Directive# S E T	: { return 2; }
#Directive# S O U R C E F O R M A T	: { return 4; }

#Directive# (Letter | Digit) ((Letter | Digit | "-") * (Letter | Digit)) ?
				: { length = GetUpper (String);
				    Attribute.name.Ident =
					MakeIdent (String, length);
				    return name; }

					/* error handling		*/

#STD, Directive# - {\ \t\n}	: { if (! in_comment_entry) {
				       MessageI ("illegal character", xxError,
				       Attribute.Position, xxCharacter, TokenPtr);
				       error_count ++;
				  } }

\t | \f | \26			:- {}