| blob | cc793d59d30aa99e4b5440a5ebf7c26fcf13b184 |
1 ------------------------------------------------------------------------------
2 -- --
3 -- GNAT COMPILER COMPONENTS --
4 -- --
5 -- S C N --
6 -- --
7 -- B o d y --
8 -- --
9 -- Copyright (C) 1992-2002 Free Software Foundation, Inc. --
10 -- --
11 -- GNAT is free software; you can redistribute it and/or modify it under --
12 -- terms of the GNU General Public License as published by the Free Soft- --
13 -- ware Foundation; either version 2, or (at your option) any later ver- --
14 -- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
15 -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
16 -- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License --
17 -- for more details. You should have received a copy of the GNU General --
18 -- Public License distributed with GNAT; see file COPYING. If not, write --
19 -- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, --
20 -- MA 02111-1307, USA. --
21 -- --
22 -- GNAT was originally developed by the GNAT team at New York University. --
23 -- Extensive contributions were provided by Ada Core Technologies Inc. --
24 -- --
25 ------------------------------------------------------------------------------
46 -- Make control characters visible
49 -- Flags set True if a given keyword is used as an identifier (used to
50 -- make sure that we only post an error message for incorrect use of a
51 -- keyword as an identifier once for a given keyword).
53 -----------------------
54 -- Local Subprograms --
55 -----------------------
59 -- This routine accumulates the checksum given character C. During the
60 -- scanning of a source file, this routine is called with every character
61 -- in the source, excluding blanks, and all control characters (except
62 -- that ESC is included in the checksum). Upper case letters not in string
63 -- literals are folded by the caller. See Sinput spec for the documentation
64 -- of the checksum algorithm. Note: checksum values are only used if we
65 -- generate code, so it is not necessary to worry about making the right
66 -- sequence of calls in any error situation.
70 -- This version is identical, except that the argument, C, is a character
71 -- code value instead of a character. This is used when wide characters
72 -- are scanned. We use the character code rather than the ASCII characters
73 -- so that the checksum is independent of wide character encoding method.
77 -- Initialize checksum value
80 -- Called when end of line encountered. Checks that line is not
81 -- too long, and that other style checks for the end of line are met.
84 -- Scan header of file and check that it has an appropriate GNAT-style
85 -- header with a proper license statement. Returns GPL, Unrestricted,
86 -- or Modified_GPL depending on header. If none of these, returns Unknown.
89 -- This function is used for double character tokens like := or <>. It
90 -- checks if the character following Source (Scan_Ptr) is C, and if so
91 -- bumps Scan_Ptr past the pair of characters and returns True. A space
92 -- between the two characters is also recognized with an appropriate
93 -- error message being issued. If C is not present, False is returned.
94 -- Note that Double_Char_Token can only be used for tokens defined in
95 -- the Ada syntax (it's use for error cases like && is not appropriate
96 -- since we do not want a junk message for a case like &-space-&).
99 -- Give illegal character error, Scan_Ptr points to character. On return,
100 -- Scan_Ptr is bumped past the illegal character.
103 -- Give illegal wide character message. On return, Scan_Ptr is bumped
104 -- past the illegal character, which may still leave us pointing to
105 -- junk, not much we can do if the escape sequence is messed up!
108 -- Signal error of excessively long line
111 -- Signal error of double underline character
114 -- This is the procedure for scanning out numeric literals. On entry,
115 -- Scan_Ptr points to the digit that starts the numeric literal (the
116 -- checksum for this character has not been accumulated yet). On return
117 -- Scan_Ptr points past the last character of the numeric literal, Token
118 -- and Token_Node are set appropriately, and the checksum is updated.
121 -- This routine is called with Scan_Ptr pointing to the first character
122 -- of a line. On exit, Scan_Ptr is advanced to the first non-blank
123 -- character of this line (or to the terminating format effector if the
124 -- line contains no non-blank characters), and the returned result is the
125 -- column number of this non-blank character (zero origin), which is the
126 -- value to be stored in the Start_Column scan variable.
129 -- This is the procedure for scanning out string literals. On entry,
130 -- Scan_Ptr points to the opening string quote (the checksum for this
131 -- character has not been accumulated yet). On return Scan_Ptr points
132 -- past the closing quote of the string literal, Token and Token_Node
133 -- are set appropriately, and the checksum is upated.
135 -------------------------
136 -- Accumulate_Checksum --
137 -------------------------
140 begin
145 begin
150 -----------------------
151 -- Check_End_Of_Line --
152 -----------------------
157 begin
159 Error_Long_Line;
166 -----------------------
167 -- Determine_License --
168 -----------------------
174 -- See if current comment contains successive non-blank characters
175 -- matching the contents of S. If so leave Scan_Ptr unchanged and
176 -- return True, otherwise leave Scan_Ptr unchanged and return False.
179 -- Skip to line terminator character
181 --------------
182 -- Contains --
183 --------------
190 begin
197 loop
219 --------------
220 -- Skip_EOL --
221 --------------
224 begin
227 loop
232 -- Start of processing for Determine_License
234 begin
235 loop
238 then
241 else
253 elsif
254 Contains
256 or else
257 Contains
259 then
263 Skip_EOL;
265 Check_End_Of_Line;
267 declare
270 begin
273 -- If we are at start of physical line, update scan pointers
274 -- to reflect the start of the new line.
285 ----------------------------
286 -- Determine_Token_Casing --
287 ----------------------------
290 begin
294 -----------------------
295 -- Double_Char_Token --
296 -----------------------
299 begin
307 then
313 else
318 -----------------------------
319 -- Error_Illegal_Character --
320 -----------------------------
323 begin
328 ----------------------------------
329 -- Error_Illegal_Wide_Character --
330 ----------------------------------
333 begin
335 Error_Msg_S
338 else
339 Error_Msg_S
346 ---------------------
347 -- Error_Long_Line --
348 ---------------------
351 begin
352 Error_Msg
357 -------------------------------
358 -- Error_No_Double_Underline --
359 -------------------------------
362 begin
366 -------------------------
367 -- Initialize_Checksum --
368 -------------------------
371 begin
375 ------------------------
376 -- Initialize_Scanner --
377 ------------------------
379 procedure Initialize_Scanner
382 is
385 begin
386 -- Set up Token_Type values in Names Table entries for reserved keywords
387 -- We use the Pos value of the Token_Type value. Note we are relying on
388 -- the fact that Token_Type'Val (0) is not a reserved word!
460 -- Initialize scan control variables
474 Initialize_Checksum;
476 -- Set default for Comes_From_Source. All nodes built now until we
477 -- reenter the analyzer will have Comes_From_Source set to True
481 -- Check license if GNAT type header possibly present
485 then
489 -- Scan initial token (note this initializes Prev_Token, Prev_Token_Ptr)
491 Scan;
493 -- Clear flags for reserved words used as identifiers
501 ----------
502 -- Nlit --
503 ----------
507 ----------
508 -- Scan --
509 ----------
512 begin
517 -- The following loop runs more than once only if a format effector
518 -- (tab, vertical tab, form feed, line feed, carriage return) is
519 -- encountered and skipped, or some error situation, such as an
520 -- illegal character, is encountered.
522 loop
523 -- Skip past blanks, loop is opened up for speed
565 -- We are now at a non-blank character, which is the first character
566 -- of the token we will scan, and hence the value of Token_Ptr.
570 -- Here begins the main case statement which transfers control on
571 -- the basis of the non-blank character we have encountered.
575 -- Line terminator characters
579 -- Check line too long
581 Check_End_Of_Line;
583 declare
586 begin
589 -- If we are at start of physical line, update scan pointers
590 -- to reflect the start of the new line.
600 -- Horizontal tab, just skip past it
606 -- End of file character, treated as an end of file only if it
607 -- is the last character in the buffer, otherwise it is ignored.
611 Check_End_Of_Line;
615 else
619 -- Ampersand
630 else
636 -- Asterisk (can be multiplication operator or double asterisk
637 -- which is the exponentiation compound delimtier).
648 else
654 -- Colon, which can either be an isolated colon, or part of an
655 -- assignment compound delimiter.
667 then
673 else
680 -- Left parenthesis
689 -- Left bracket
696 else
703 -- Left brace
711 -- Comma
720 -- Dot, which is either an isolated period, or part of a double
721 -- dot compound delimiter sequence. We also check for the case of
722 -- a digit following the period, to give a better error message.
736 else
742 -- Equal, which can either be an equality operator, or part of the
743 -- arrow (=>) compound delimiter.
762 -- Greater than, which can be a greater than operator, greater than
763 -- or equal operator, or first character of a right label bracket.
776 else
782 -- Less than, which can be a less than operator, less than or equal
783 -- operator, or the first character of a left label bracket, or the
784 -- first character of a box (<>) compound delimiter.
802 else
808 -- Minus, which is either a subtraction operator, or the first
809 -- character of double minus starting a comment
824 -- Comment
830 -- Loop to scan comment (this loop runs more than once only if
831 -- a horizontal tab or other non-graphic character is scanned)
833 loop
834 -- Scan to non graphic character (opened up for speed)
836 loop
849 -- Keep going if horizontal tab
855 -- Terminate scan of comment if line terminator
860 -- Terminate scan of comment if end of file encountered
861 -- (embedded EOF character or real last character in file)
866 -- Keep going if character in 80-FF range, or is ESC. These
867 -- characters are allowed in comments by RM-2.1(1), 2.7(2).
868 -- They are allowed even in Ada 83 mode according to the
869 -- approved AI. ESC was added to the AI in June 93.
873 then
876 -- Otherwise we have an illegal comment character
878 else
879 Error_Illegal_Character;
884 -- Note that we do NOT execute a return here, instead we fall
885 -- through to reexecute the scan loop to look for a token.
890 -- Double quote or percent starting a string literal
893 Slit;
896 -- Apostrophe. This can either be the start of a character literal,
897 -- or an isolated apostrophe used in a qualified expression or an
898 -- attribute. We treat it as a character literal if it does not
899 -- follow a right parenthesis, identifier, the keyword ALL or
900 -- a literal. This means that we correctly treat constructs like:
902 -- A := CHARACTER'('A');
904 -- Note that RM-2.2(7) does not require a separator between
905 -- "CHARACTER" and "'" in the above.
911 begin
915 -- Here is where we make the test to distinguish the cases. Treat
916 -- as apostrophe if previous token is an identifier, right paren
917 -- or the reserved word "all" (latter case as in A.all'Address)
918 -- Also treat it as apostrophe after a literal (this catches
919 -- some legitimate cases, like A."abs"'Address, and also gives
920 -- better error behavior for impossible cases like 123'xxx).
926 then
930 -- Otherwise the apostrophe starts a character literal
932 else
933 -- Case of wide character literal with ESC or [ encoding
936 and then
938 or else
940 and then
941 Upper_Half_Encoding)
942 or else
944 and then
946 then
951 Error_Illegal_Wide_Character;
956 else
960 -- If we do not find a closing quote in the expected place then
961 -- assume that we have a misguided attempt at a string literal.
963 -- However, if previous token is RANGE, then we return an
964 -- apostrophe instead since this gives better error recovery
972 else
974 Error_Msg_S
980 -- Otherwise we have a (non-wide) character literal
982 else
988 Error_Illegal_Character;
991 else
992 Error_Illegal_Character;
1000 -- Fall through here with Scan_Ptr updated past the closing
1001 -- quote, and Code set to the Char_Code value for the literal
1014 -- Right parenthesis
1023 -- Right bracket or right brace, treated as right paren
1031 -- Slash (can be division operator or first character of not equal)
1039 else
1045 -- Semicolon
1054 -- Vertical bar
1059 -- Special check for || to give nice message
1067 else
1075 -- Exclamation, replacement character for vertical bar
1086 else
1094 -- Plus
1103 -- Digits starting a numeric literal
1106 Nlit;
1109 Error_Msg_S
1115 -- Lower case letters
1124 -- Upper case letters
1134 -- Underline character
1143 -- Space (not possible, because we scanned past blanks)
1148 -- Characters in top half of ASCII 8-bit chart
1152 -- Wide character case. Note that Scan_Identifier will issue
1153 -- an appropriate message if wide characters are not allowed
1154 -- in identifiers.
1160 -- Otherwise we have OK Latin-1 character
1162 else
1163 -- Upper half characters may possibly be identifier letters
1164 -- but can never be digits, so Identifier_Char can be used
1165 -- to test for a valid start of identifier character.
1170 else
1171 Error_Illegal_Character;
1177 -- ESC character, possible start of identifier if wide characters
1178 -- using ESC encoding are allowed in identifiers, which we can
1179 -- tell by looking at the Identifier_Char flag for ESC, which is
1180 -- only true if these conditions are met.
1185 else
1186 Error_Illegal_Wide_Character;
1189 -- Invalid control characters
1191 when NUL | SOH | STX | ETX | EOT | ENQ | ACK | BEL | BS | SO |
1192 SI | DLE | DC1 | DC2 | DC3 | DC4 | NAK | SYN | ETB | CAN |
1193 EM | FS | GS | RS | US | DEL
1194 =>
1195 Error_Illegal_Character;
1197 -- Invalid graphic characters
1200 Error_Illegal_Character;
1202 -- End switch on non-blank character
1206 -- End loop past format effectors. The exit from this loop is by
1207 -- executing a return statement following completion of token scan
1208 -- (control never falls out of this loop to the code which follows)
1212 -- Identifier scanning routine. On entry, some initial characters
1213 -- of the identifier may have already been stored in Name_Buffer.
1214 -- If so, Name_Len has the number of characters stored. otherwise
1215 -- Name_Len is set to zero on entry.
1219 -- This loop scans as fast as possible past lower half letters
1220 -- and digits, which we expect to be the most common characters.
1222 loop
1225 then
1233 else
1237 -- Open out the loop a couple of times for speed
1241 then
1250 else
1258 then
1266 else
1274 then
1283 else
1293 -- If we fall through, then we have encountered either an underline
1294 -- character, or an extended identifier character (i.e. one from the
1295 -- upper half), or a wide character, or an identifier terminator.
1296 -- The initial test speeds us up in the most common case where we
1297 -- have an identifier terminator. Note that ESC is an identifier
1298 -- character only if a wide character encoding method that uses
1299 -- ESC encoding is active, so if we find an ESC character we know
1300 -- that we have a wide character.
1304 -- Case of underline, check for error cases of double underline,
1305 -- and for a trailing underline character
1316 Error_No_Double_Underline;
1319 else
1326 -- Upper half character
1329 and then not Upper_Half_Encoding
1330 then
1332 Store_Encoded_Character
1337 -- Left bracket not followed by a quote terminates an identifier.
1338 -- This is an error, but we don't want to give a junk error msg
1339 -- about wide characters in this case!
1343 then
1346 -- We know we have a wide character encoding here (the current
1347 -- character is either ESC, left bracket, or an upper half
1348 -- character depending on the encoding method).
1350 else
1351 -- Scan out the wide character and insert the appropriate
1352 -- encoding into the name table entry for the identifier.
1354 declare
1360 begin
1363 -- If error, signal error
1366 Error_Illegal_Wide_Character;
1368 -- If the character scanned is a normal identifier
1369 -- character, then we treat it that way.
1373 then
1376 Store_Encoded_Character
1379 -- Character is not normal identifier character, store
1380 -- it in encoded form.
1382 else
1386 -- Make sure we are allowing wide characters in
1387 -- identifiers. Note that we allow wide character
1388 -- notation for an OK identifier character. This
1389 -- in particular allows bracket or other notation
1390 -- to be used for upper half letters.
1393 Error_Msg
1403 -- Scan of identifier is complete. The identifier is stored in
1404 -- Name_Buffer, and Scan_Ptr points past the last character.
1408 -- Here is where we check if it was a keyword
1412 then
1415 -- Deal with possible style check for non-lower case keyword,
1416 -- but we don't treat ACCESS, DELTA, DIGITS, RANGE as keywords
1417 -- for this purpose if they appear as attribute designators.
1418 -- Actually we only check the first character for speed.
1420 if Style_Check
1423 or else
1428 then
1432 -- We must reset Token_Name since this is not an identifier
1433 -- and if we leave Token_Name set, the parser gets confused
1434 -- because it thinks it is dealing with an identifier instead
1435 -- of the corresponding keyword.
1440 -- It is an identifier after all
1442 else
1450 ---------------------
1451 -- Scan_First_Char --
1452 ---------------------
1457 begin
1458 loop
1466 else
1472 ------------------------------
1473 -- Scan_Reserved_Identifier --
1474 ------------------------------
1479 begin
1480 -- We have in Token_Chars the image of the Token name, i.e. Tok_xxx.
1481 -- This code extracts the xxx and makes an identifier out of it.
1503 ----------------------
1504 -- Set_Start_Column --
1505 ----------------------
1507 -- Note: it seems at first glance a little expensive to compute this value
1508 -- for every source line (since it is certainly not used for all source
1509 -- lines). On the other hand, it doesn't take much more work to skip past
1510 -- the initial white space on the line counting the columns than it would
1511 -- to scan past the white space using the standard scanning circuits.
1516 begin
1517 -- Outer loop scans past horizontal tab characters
1521 -- Inner loop scans past blanks as fast as possible, bumping Scan_Ptr
1522 -- past the blanks and adjusting Start_Column to account for them.
1534 else
1539 else
1544 else
1549 else
1554 else
1559 else
1564 else
1569 -- Outer loop keeps going only if a horizontal tab follows
1575 else
1584 ----------
1585 -- Slit --
1586 ----------