0001: /*
0002: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
0003: *
0004: * Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
0005: *
0006: * The contents of this file are subject to the terms of either the GNU
0007: * General Public License Version 2 only ("GPL") or the Common
0008: * Development and Distribution License("CDDL") (collectively, the
0009: * "License"). You may not use this file except in compliance with the
0010: * License. You can obtain a copy of the License at
0011: * http://www.netbeans.org/cddl-gplv2.html
0012: * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
0013: * specific language governing permissions and limitations under the
0014: * License. When distributing the software, include this License Header
0015: * Notice in each file and include the License file at
0016: * nbbuild/licenses/CDDL-GPL-2-CP. Sun designates this
0017: * particular file as subject to the "Classpath" exception as provided
0018: * by Sun in the GPL Version 2 section of the License file that
0019: * accompanied this code. If applicable, add the following below the
0020: * License Header, with the fields enclosed by brackets [] replaced by
0021: * your own identifying information:
0022: * "Portions Copyrighted [year] [name of copyright owner]"
0023: *
0024: * Contributor(s):
0025: *
0026: * The Original Software is NetBeans. The Initial Developer of the Original
0027: * Software is Sun Microsystems, Inc. Portions Copyright 1997-2007 Sun
0028: * Microsystems, Inc. All Rights Reserved.
0029: *
0030: * If you wish your version of this file to be governed by only the CDDL
0031: * or only the GPL Version 2, indicate your decision by adding
0032: * "[Contributor] elects to include this software in this distribution
0033: * under the [CDDL or GPL Version 2] license." If you do not indicate a
0034: * single choice of license, a recipient has the option to distribute
0035: * your version of this file under either the CDDL, the GPL Version 2 or
0036: * to extend the choice of license to its licensees as provided above.
0037: * However, if you add GPL Version 2 code and therefore, elected the GPL
0038: * Version 2 license, then the option applies only if the new code is
0039: * made subject to such option by the copyright holder.
0040: */
0041:
0042: package org.netbeans.modules.cnd.editor.fortran;
0043:
0044: import org.netbeans.editor.Syntax;
0045: import org.netbeans.editor.TokenID;
0046:
0047: import org.netbeans.modules.cnd.settings.CppSettings;
0048:
0049: /**
0050: * Syntax analyzes for Fortran source files.
0051: * Tokens and internal states are given below.
0052: *
0053: */
0054:
0055: public class FSyntax extends Syntax {
0056:
0057: //internal analyzer states
0058: //numbers assigned to states are not important as long as they are unique
0059: private static final int AFTER_SLASH = 1; // after slash char
0060: private static final int AFTER_EQ = 2; // after '='
0061: private static final int AFTER_STAR = 3; // after '*'
0062: private static final int AFTER_LESSTHAN = 4; // after '<'
0063: private static final int AFTER_GREATERTHAN = 5; // after '>'
0064: private static final int AFTER_B = 6; // after 'b' or 'B'
0065: private static final int AFTER_O = 7; // after 'o' or 'O'
0066: private static final int AFTER_Z = 8; // after 'z' or 'Z'
0067: private static final int AFTER_DOT = 9; // after '.'
0068:
0069: private static final int IN_STRING = 10; // inside string constant
0070: private static final int IN_STRING_AFTER_BSLASH = 11; //inside string const
0071: // after backslash
0072: private static final int IN_LINE_COMMENT = 12; // inside line comment
0073: private static final int IN_IDENTIFIER = 13; // inside identifier
0074: private static final int IN_DOT_IDENTIFIER = 14; // inside .identifier
0075: private static final int IN_WHITESPACE = 15; // inside white space
0076: private static final int IN_INT = 16; // integer number
0077: private static final int IN_BINARY = 17; // binary number
0078: private static final int IN_OCTAL = 18; // octal number
0079: private static final int IN_HEX = 19; // hex number
0080: private static final int IN_REAL = 20; // real number
0081:
0082: /**specifies if the string is defined in double quotes
0083: * or single quote
0084: */
0085: private static boolean STRING_IN_DOUBLE_QUOTE = true;
0086:
0087: /**this variable is put for detecting the "_" in integers and reals
0088: */
0089: private static boolean HAS_NUMERIC_UNDERSCORE = false;
0090:
0091: /**points to the last newline character
0092: */
0093: protected int lastNL = 0;
0094:
0095: /** constructor
0096: */
0097: public FSyntax() {
0098: tokenContextPath = FTokenContext.contextPath;
0099: }
0100:
0101: /** This function returns true if the colun number
0102: * exceeds the limit defined by FSettingsDefaults.maximumTextWidth
0103: * otherwise it returns null
0104: */
0105: protected boolean isLineBeyondLimit() {
0106: if ((offset - lastNL > FSettingsDefaults.maximumTextWidth)
0107: && (lastNL >= 0) && (state != IN_LINE_COMMENT)) {
0108: state = IN_LINE_COMMENT;
0109: return true;
0110: }
0111:
0112: return false;
0113: }
0114:
0115: /** This is core function of analyzer and it returns either the token-id
0116: * or null to indicate that the end of buffer was found.
0117: * The function scans the active character and does one or more
0118: * of the following actions:
0119: * 1. change internal analyzer state
0120: * 2. set the token-context-path and return token-id
0121: * 3. adjust current position to signal different end of token;
0122: * the character that offset points to is not included in the token
0123: */
0124: protected TokenID parseToken() {
0125: char actChar;
0126: //WHILE OFFSET
0127: while (offset < stopOffset) {
0128: actChar = buffer[offset];
0129:
0130: //STATE SWITCH
0131: switch (state) {
0132: //INIT STATE
0133: case INIT:
0134: if (isLineBeyondLimit()) {
0135: offset--; //reevaluate the char
0136: break;
0137: }
0138: switch (actChar) {
0139: case '\n':
0140: lastNL = offset;
0141: offset++;
0142: return FTokenContext.WHITESPACE;
0143: case 'b':
0144: case 'B':
0145: state = AFTER_B;
0146: break;
0147: case 'o':
0148: case 'O':
0149: state = AFTER_O;
0150: break;
0151: case 'z':
0152: case 'Z':
0153: state = AFTER_Z;
0154: break;
0155: case '"':
0156: //make sure that this case is always after cases b, o and z
0157: state = IN_STRING;
0158: STRING_IN_DOUBLE_QUOTE = true;
0159: break;
0160: case '\'': {
0161: //make sure that this case is always after cases b, o and z
0162: if (offset > 0) { //fix for 4838228 Error generated ...
0163: char beforeApostrophe = buffer[offset - 1];
0164: if (Character
0165: .isJavaIdentifierPart(beforeApostrophe)) { //e.g. L'
0166: offset++;
0167: return FTokenContext.APOSTROPHE_CHAR;
0168: }
0169: }
0170: state = IN_STRING;
0171: STRING_IN_DOUBLE_QUOTE = false;
0172: break;
0173: }
0174: case '/':
0175: state = AFTER_SLASH;
0176: break;
0177: case '=':
0178: state = AFTER_EQ;
0179: break;
0180: case '+':
0181: offset++;
0182: return FTokenContext.OP_PLUS;
0183: case '-':
0184: offset++;
0185: return FTokenContext.OP_MINUS;
0186: case '*':
0187: state = AFTER_STAR;
0188: break;
0189: case '!':
0190: // Fortran comments begin with a ! and last to end of line
0191: state = IN_LINE_COMMENT;
0192: break;
0193: case 'C':
0194: case 'c':
0195: if ((lastNL == offset - 1 || offset == 0)
0196: && !CppSettings.getDefault()
0197: .isFreeFormatFortran())
0198: state = IN_LINE_COMMENT;
0199: break;
0200: case '<':
0201: state = AFTER_LESSTHAN;
0202: break;
0203: case '>':
0204: state = AFTER_GREATERTHAN;
0205: break;
0206: case '.':
0207: state = AFTER_DOT;
0208: break;
0209: case ',':
0210: offset++;
0211: return FTokenContext.COMMA;
0212: case ':':
0213: offset++;
0214: return FTokenContext.COLON;
0215: case '%':
0216: offset++;
0217: return FTokenContext.PERCENT;
0218: case '&':
0219: offset++;
0220: return FTokenContext.AMPERSAND;
0221: case '(':
0222: offset++;
0223: return FTokenContext.LPAREN;
0224: case ')':
0225: offset++;
0226: return FTokenContext.RPAREN;
0227: case ';':
0228: offset++;
0229: return FTokenContext.SEMICOLON;
0230: case '?':
0231: offset++;
0232: return FTokenContext.QUESTION_MARK;
0233: case '$':
0234: offset++;
0235: return FTokenContext.CURRENCY;
0236: default:
0237: // Check for whitespace
0238: if (Character.isWhitespace(actChar)) {
0239: state = IN_WHITESPACE;
0240: break;
0241: }
0242:
0243: // Check for digit
0244: if (Character.isDigit(actChar)) {
0245: state = IN_INT;
0246: break;
0247: }
0248:
0249: // Check for identifier
0250: // To find out why we're using isJAVAidentifier
0251: // here, grep for isJavaIdentifierStart in
0252: // CCSyntax.java
0253: if (Character.isJavaIdentifierStart(actChar)) {
0254: state = IN_IDENTIFIER;
0255: break;
0256: }
0257:
0258: offset++;
0259: return FTokenContext.ERR_INVALID_CHAR;
0260: }//switch(actchar)
0261: break;
0262: //END INIT STATE
0263:
0264: case IN_WHITESPACE: // white space
0265: if (isLineBeyondLimit()) {
0266: return FTokenContext.WHITESPACE;
0267: }
0268: if ((!Character.isWhitespace(actChar))
0269: || (actChar == '\n')) {
0270: state = INIT;
0271: return FTokenContext.WHITESPACE;
0272: }
0273: break;
0274:
0275: case AFTER_B:
0276: if (isLineBeyondLimit()) {
0277: return FTokenContext.IDENTIFIER;
0278: }
0279: switch (actChar) {
0280: case '"':
0281: case '\'':
0282: if (Character.isDigit(buffer[offset + 1])) {
0283: state = IN_BINARY;
0284: break;
0285: } //else continue to default
0286: default:
0287: state = IN_IDENTIFIER;
0288: offset--; //go back and evaluate the character
0289: break;
0290: }//switch AFTER_B
0291: break;
0292:
0293: case AFTER_O:
0294: if (isLineBeyondLimit()) {
0295: return FTokenContext.IDENTIFIER;
0296: }
0297: switch (actChar) {
0298: case '"':
0299: case '\'':
0300: if (Character.isDigit(buffer[offset + 1])) {
0301: state = IN_OCTAL;
0302: break;
0303: } //else continue to default
0304: default:
0305: state = IN_IDENTIFIER;
0306: offset--; //go back and evaluate the character
0307: break;
0308: }//switch AFTER_O
0309: break;
0310:
0311: case AFTER_Z:
0312: if (isLineBeyondLimit()) {
0313: return FTokenContext.IDENTIFIER;
0314: }
0315: switch (actChar) {
0316: case '"':
0317: case '\'':
0318: if (Character.isLetterOrDigit(buffer[offset + 1])) {
0319: state = IN_HEX;
0320: break;
0321: } //else continue to default
0322: default:
0323: state = IN_IDENTIFIER;
0324: offset--; //go back and evaluate the character
0325: break;
0326: }//switch AFTER_Z
0327: break;
0328:
0329: case IN_LINE_COMMENT:
0330: switch (actChar) {
0331: case '\n':
0332: state = INIT;
0333: lastNL = offset;
0334: offset++;
0335: return FTokenContext.LINE_COMMENT;
0336: }//switch IN_LINE_COMMENT
0337: break;
0338:
0339: case IN_STRING:
0340: if (isLineBeyondLimit()) {
0341: return FTokenContext.ERR_INCOMPLETE_STRING_LITERAL;
0342: }
0343: switch (actChar) {
0344: case '\\':
0345: state = IN_STRING_AFTER_BSLASH;
0346: break;
0347: case '\n':
0348: state = INIT;
0349: lastNL = offset;
0350: offset++;
0351: supposedTokenID = FTokenContext.STRING_LITERAL;
0352: //return FTokenContext.INCOMPLETE_STRING_LITERAL;
0353: return supposedTokenID;
0354: case '"':
0355: if (STRING_IN_DOUBLE_QUOTE) {
0356: offset++;
0357: state = INIT;
0358: return FTokenContext.STRING_LITERAL;
0359: }
0360: break;
0361: case '\'':
0362: if (!STRING_IN_DOUBLE_QUOTE) {
0363: offset++;
0364: state = INIT;
0365: return FTokenContext.STRING_LITERAL;
0366: }
0367: break;
0368: } //switch IN_STRING
0369: break;
0370:
0371: case IN_STRING_AFTER_BSLASH:
0372: if (isLineBeyondLimit()) {
0373: return FTokenContext.ERR_INCOMPLETE_STRING_LITERAL;
0374: }
0375: switch (actChar) {
0376: case '"':
0377: case '\'':
0378: case '\\':
0379: break; //ignore the meaning of these characters
0380: default:
0381: offset--; //go back and evaluate the character
0382: break;
0383: }//switch IN_STRING_AFTER_BSLASH:
0384: state = IN_STRING;
0385: break;
0386:
0387: case AFTER_SLASH:
0388: if (isLineBeyondLimit()) {
0389: return FTokenContext.OP_DIV;
0390: }
0391: switch (actChar) {
0392: case '/':
0393: offset++;
0394: state = INIT;
0395: return FTokenContext.OP_CONCAT;
0396: case '=':
0397: offset++;
0398: state = INIT;
0399: return FTokenContext.OP_NOT_EQ;
0400: default:
0401: state = INIT;
0402: return FTokenContext.OP_DIV;
0403: }//switch AFTER_SLASH
0404: //break;
0405:
0406: case AFTER_EQ:
0407: if (isLineBeyondLimit()) {
0408: return FTokenContext.EQ;
0409: }
0410: switch (actChar) {
0411: case '=':
0412: offset++;
0413: state = INIT;
0414: return FTokenContext.OP_LOG_EQ;
0415: default:
0416: state = INIT;
0417: return FTokenContext.EQ;
0418: }//switch AFTER_EQ
0419: //break;
0420:
0421: case AFTER_STAR:
0422: if (isLineBeyondLimit()) {
0423: return FTokenContext.OP_MUL;
0424: }
0425: switch (actChar) {
0426: case '*':
0427: offset++;
0428: state = INIT;
0429: return FTokenContext.OP_POWER;
0430: default:
0431: state = INIT;
0432: return FTokenContext.OP_MUL;
0433: }//switch AFTER_STAR
0434: //break;
0435:
0436: case AFTER_LESSTHAN:
0437: if (isLineBeyondLimit()) {
0438: return FTokenContext.OP_LT;
0439: }
0440: switch (actChar) {
0441: case '=':
0442: offset++;
0443: state = INIT;
0444: return FTokenContext.OP_LT_EQ;
0445: default:
0446: state = INIT;
0447: return FTokenContext.OP_LT;
0448: }//switch AFTER_LESSTHAN
0449: //break;
0450:
0451: case AFTER_GREATERTHAN:
0452: if (isLineBeyondLimit()) {
0453: return FTokenContext.OP_GT;
0454: }
0455: switch (actChar) {
0456: case '=':
0457: offset++;
0458: state = INIT;
0459: return FTokenContext.OP_GT_EQ;
0460: default:
0461: state = INIT;
0462: return FTokenContext.OP_GT;
0463: }//switch AFTER_GREATERTHAN
0464: //break;
0465:
0466: case IN_IDENTIFIER:
0467: if (isLineBeyondLimit()) {
0468: TokenID tid = matchKeyword(buffer, tokenOffset,
0469: offset - tokenOffset);
0470: return (tid != null) ? tid
0471: : FTokenContext.IDENTIFIER;
0472: }
0473: // To find out why we're using isJAVAidentifier
0474: // here, grep for isJavaIdentifierStart in
0475: // CCSyntax.java
0476:
0477: //check if it is a keyword ending with a "="
0478: if (actChar == '=') {
0479: //+1 is for "=" sign
0480: TokenID tid = matchKeyword(buffer, tokenOffset,
0481: offset - tokenOffset + 1);
0482: if (tid != null) {
0483: offset++;
0484: state = INIT;
0485: return tid;
0486: }
0487: }
0488:
0489: if (!(Character.isJavaIdentifierPart(actChar))) {
0490: state = INIT;
0491: TokenID tid = matchKeyword(buffer, tokenOffset,
0492: offset - tokenOffset);
0493: return (tid != null) ? tid
0494: : FTokenContext.IDENTIFIER;
0495: }
0496: break;
0497:
0498: case IN_BINARY:
0499: if (isLineBeyondLimit()) {
0500: return FTokenContext.ERR_INVALID_BINARY_LITERAL;
0501: }
0502: if ((actChar == '\'' || actChar == '"')) {
0503: state = INIT;
0504: offset++;
0505: return FTokenContext.NUM_LITERAL_BINARY;
0506: } else if (((Character.isDigit(actChar)) && (actChar > '1'))
0507: || !(Character.isDigit(actChar))) {
0508: state = INIT;
0509: return FTokenContext.ERR_INVALID_BINARY_LITERAL;
0510: }
0511: break;
0512:
0513: case IN_OCTAL:
0514: if (isLineBeyondLimit()) {
0515: return FTokenContext.ERR_INVALID_OCTAL_LITERAL;
0516: }
0517: if ((actChar == '\'' || actChar == '"')) {
0518: state = INIT;
0519: offset++;
0520: return FTokenContext.NUM_LITERAL_OCTAL;
0521: } else if (((Character.isDigit(actChar)) && (actChar > '7'))
0522: || !(Character.isDigit(actChar))) {
0523: state = INIT;
0524: return FTokenContext.ERR_INVALID_OCTAL_LITERAL;
0525: }
0526: break;
0527:
0528: case IN_HEX:
0529: if (isLineBeyondLimit()) {
0530: return FTokenContext.ERR_INVALID_HEX_LITERAL;
0531: }
0532: if ((actChar == '\'' || actChar == '"')) {
0533: state = INIT;
0534: offset++;
0535: return FTokenContext.NUM_LITERAL_HEX;
0536: } else if (!(Character.isDigit(actChar))
0537: && ((Character.toLowerCase(actChar) < 'a') || (Character
0538: .toLowerCase(actChar) > 'f'))) {
0539: state = INIT;
0540: return FTokenContext.ERR_INVALID_HEX_LITERAL;
0541: }
0542: break;
0543:
0544: case IN_INT:
0545: if (isLineBeyondLimit()) {
0546: return FTokenContext.NUM_LITERAL_INT;
0547: }
0548: switch (actChar) {
0549: case '_':
0550: offset++;
0551: HAS_NUMERIC_UNDERSCORE = true;
0552: break;
0553: case '.':
0554: if (HAS_NUMERIC_UNDERSCORE) {
0555: offset++;
0556: state = INIT;
0557: HAS_NUMERIC_UNDERSCORE = false;
0558: return FTokenContext.ERR_INVALID_INTEGER;
0559: } else {
0560: state = IN_REAL;
0561: break;
0562: }
0563: case 'd':
0564: case 'D':
0565: case 'e':
0566: case 'E':
0567: if (!HAS_NUMERIC_UNDERSCORE)
0568: state = IN_REAL;
0569: break;
0570: default:
0571: if (((HAS_NUMERIC_UNDERSCORE) && (!(Character
0572: .isLetterOrDigit(actChar))))
0573: || ((!HAS_NUMERIC_UNDERSCORE) && (!(Character
0574: .isDigit(actChar))))) {
0575: state = INIT;
0576: HAS_NUMERIC_UNDERSCORE = false;
0577: return FTokenContext.NUM_LITERAL_INT;
0578: }
0579: }//switch
0580: break;
0581:
0582: case IN_REAL:
0583: if (isLineBeyondLimit()) {
0584: return FTokenContext.NUM_LITERAL_REAL;
0585: }
0586: switch (actChar) {
0587: case '_':
0588: offset++;
0589: HAS_NUMERIC_UNDERSCORE = true;
0590: break;
0591: case 'd':
0592: case 'D':
0593: case 'e':
0594: case 'E':
0595: if (!HAS_NUMERIC_UNDERSCORE)
0596: break;
0597: default:
0598: if (((HAS_NUMERIC_UNDERSCORE) && (!(Character
0599: .isLetterOrDigit(actChar))))
0600: || ((!HAS_NUMERIC_UNDERSCORE) && (!(Character
0601: .isDigit(actChar))))) {
0602: state = INIT;
0603: HAS_NUMERIC_UNDERSCORE = false;
0604: return FTokenContext.NUM_LITERAL_REAL;
0605: }
0606: }//switch
0607: break;
0608:
0609: case AFTER_DOT:
0610: if (isLineBeyondLimit()) {
0611: return FTokenContext.DOT;
0612: }
0613: // To find out why we're using isJAVAidentifier
0614: // here, grep for isJavaIdentifierStart in
0615: // CCSyntax.java
0616: if (Character.isDigit(actChar))
0617: state = IN_REAL;
0618: else if (Character.isJavaIdentifierPart(actChar))
0619: // Keyword, like .gt., .le., etc.
0620: state = IN_DOT_IDENTIFIER;
0621: else {
0622: state = INIT;
0623: return FTokenContext.DOT;
0624: }
0625: break;
0626:
0627: case IN_DOT_IDENTIFIER:
0628: if (isLineBeyondLimit()) {
0629: //highlight the first dot and reevaluate the rest of the string since dot
0630: offset = tokenOffset + 1;
0631: state = INIT;
0632: return FTokenContext.DOT;
0633: }
0634: if (!Character.isJavaIdentifierPart(actChar)) {
0635: //if char is "." we have to move the offset to the next char
0636: //before evaluating the string
0637: offset += (actChar == '.') ? 1 : 0;
0638: state = INIT;
0639: TokenID tid = matchKeyword(buffer, tokenOffset,
0640: offset - tokenOffset);
0641: if (tid != null)
0642: return tid;
0643: else {
0644: //highlight the first dot and reevaluate the rest of the string since dot
0645: offset = tokenOffset + 1;
0646: state = INIT;
0647: return FTokenContext.DOT;
0648: }
0649: }
0650: break;
0651:
0652: } // end of switch(state)
0653: //END STATE SWITCH
0654: offset++;
0655: } //while(offset...)
0656: //END WHILE OFFSET
0657:
0658: /** At this stage there's no more text in the scanned buffer.
0659: * Scanner first checks whether this is completely the last
0660: * available buffer.
0661: */
0662: if (lastBuffer) {
0663: switch (state) {
0664: case IN_WHITESPACE:
0665: state = INIT;
0666: return FTokenContext.WHITESPACE;
0667: case AFTER_B:
0668: case AFTER_O:
0669: case AFTER_Z:
0670: state = INIT;
0671: return FTokenContext.IDENTIFIER;
0672: case IN_BINARY:
0673: state = INIT;
0674: return FTokenContext.ERR_INVALID_BINARY_LITERAL;
0675: case IN_OCTAL:
0676: state = INIT;
0677: return FTokenContext.ERR_INVALID_OCTAL_LITERAL;
0678: case IN_HEX:
0679: state = INIT;
0680: return FTokenContext.ERR_INVALID_HEX_LITERAL;
0681: case IN_DOT_IDENTIFIER:
0682: case IN_IDENTIFIER:
0683: state = INIT;
0684: TokenID kwd = matchKeyword(buffer, tokenOffset, offset
0685: - tokenOffset);
0686: return (kwd != null) ? kwd : FTokenContext.IDENTIFIER;
0687: case IN_STRING:
0688: case IN_STRING_AFTER_BSLASH:
0689: return FTokenContext.STRING_LITERAL; // hold the state
0690: case AFTER_SLASH:
0691: state = INIT;
0692: return FTokenContext.OP_DIV;
0693: case AFTER_EQ:
0694: state = INIT;
0695: return FTokenContext.EQ;
0696: case AFTER_STAR:
0697: state = INIT;
0698: return FTokenContext.OP_MUL;
0699: case IN_LINE_COMMENT:
0700: return FTokenContext.LINE_COMMENT; //stay in line-comment state
0701: case AFTER_LESSTHAN:
0702: state = INIT;
0703: return FTokenContext.OP_LT;
0704: case AFTER_GREATERTHAN:
0705: state = INIT;
0706: return FTokenContext.OP_GT;
0707: case IN_INT:
0708: state = INIT;
0709: return FTokenContext.NUM_LITERAL_INT;
0710: case IN_REAL:
0711: state = INIT;
0712: return FTokenContext.NUM_LITERAL_REAL;
0713: case AFTER_DOT:
0714: state = INIT;
0715: return FTokenContext.DOT;
0716:
0717: } //switch
0718: }//if (lastbuffer)
0719:
0720: /* At this stage there's no more text in the scanned buffer, but
0721: * this buffer is not the last so the scan will continue on another
0722: * buffer. The scanner tries to minimize the amount of characters
0723: * that will be prescanned in the next buffer by returning the token
0724: * where possible.
0725: */
0726: switch (state) {
0727: case IN_WHITESPACE:
0728: return FTokenContext.WHITESPACE;
0729: }
0730:
0731: return null; // nothing found
0732: }
0733:
0734: public String getStateName(int stateNumber) {
0735: switch (stateNumber) {
0736: case IN_WHITESPACE:
0737: return "IN_WHITESPACE"; //NOI18N
0738: case IN_LINE_COMMENT:
0739: return "IN_LINE_COMMENT"; //NOI18N
0740: case IN_STRING:
0741: return "IN_STRING"; //NOI18N
0742: case IN_STRING_AFTER_BSLASH:
0743: return "IN_STRING_AFTER_BSLASH"; //NOI18N
0744: case IN_IDENTIFIER:
0745: return "IN_IDENTIFIER"; //NOI18N
0746: case IN_DOT_IDENTIFIER:
0747: return "IN_DOT_IDENTIFIER"; //NOI18N
0748: case IN_BINARY:
0749: return "IN_BINARY"; //NOI18N
0750: case IN_OCTAL:
0751: return "IN_OCTAL"; //NOI18N
0752: case IN_HEX:
0753: return "IN_HEX"; //NOI18N
0754: case IN_INT:
0755: return "IN_INT"; //NOI18N
0756: case IN_REAL:
0757: return "IN_REAL"; //NOI18N
0758: case AFTER_B:
0759: return "AFTER_B"; //NOI18N
0760: case AFTER_O:
0761: return "AFTER_O"; //NOI18N
0762: case AFTER_Z:
0763: return "AFTER_Z"; //NOI18N
0764: case AFTER_SLASH:
0765: return "AFTER_SLASH"; //NOI18N
0766: case AFTER_EQ:
0767: return "AFTER_EQ"; //NOI18N
0768: case AFTER_STAR:
0769: return "AFTER_STAR"; //NOI18N
0770: case AFTER_LESSTHAN:
0771: return "AFTER_LESSTHAN"; //NOI18N
0772: case AFTER_GREATERTHAN:
0773: return "AFTER_GREATERTHAN"; //NOI18N
0774: case AFTER_DOT:
0775: return "AFTER_DOT"; //NOI18N
0776: default:
0777: return super .getStateName(stateNumber);
0778: }
0779: }
0780:
0781: public static TokenID matchKeyword(char[] buffer, int offset,
0782: int len) {
0783: if (len > 17)
0784: return null;
0785: if (len <= 1)
0786: return null;
0787: //BEGIN MOTHER SWITCH
0788: switch (Character.toLowerCase(buffer[offset++])) {
0789: //DOT
0790: // .and. .eq. .eqv. .false. .ge. .gt. .le. .lt. .ne. .neqv. .not. .or. .true.
0791: case '.':
0792: if ((len < 4) || (len > 7))
0793: return null;
0794: switch (Character.toLowerCase(buffer[offset++])) {
0795: case 'a': // .and.
0796: return (len == 5
0797: && Character.toLowerCase(buffer[offset++]) == 'n'
0798: && Character.toLowerCase(buffer[offset++]) == 'd' && Character
0799: .toLowerCase(buffer[offset++]) == '.') ? FTokenContext.KWOP_AND
0800: : null;
0801: case 'e': // .eq. .eqv.
0802: switch (Character.toLowerCase(buffer[offset++])) {
0803: case 'q': // else, elseif, elsewhere
0804: if (len == 4
0805: && Character.toLowerCase(buffer[offset++]) == '.')
0806: return FTokenContext.KWOP_EQ;
0807: else if (len == 5
0808: && Character.toLowerCase(buffer[offset++]) == 'v'
0809: && Character.toLowerCase(buffer[offset++]) == '.')
0810: return FTokenContext.KWOP_EQV;
0811: else
0812: return null;
0813:
0814: default:
0815: return null;
0816: }
0817:
0818: case 'f': //false
0819: return (len == 7
0820: && Character.toLowerCase(buffer[offset++]) == 'a'
0821: && Character.toLowerCase(buffer[offset++]) == 'l'
0822: && Character.toLowerCase(buffer[offset++]) == 's'
0823: && Character.toLowerCase(buffer[offset++]) == 'e' && Character
0824: .toLowerCase(buffer[offset++]) == '.') ? FTokenContext.KWOP_FALSE
0825: : null;
0826:
0827: case 'g': // ge, gt
0828: switch (Character.toLowerCase(buffer[offset++])) {
0829: case 'e': // ge
0830: return (len == 4 && Character
0831: .toLowerCase(buffer[offset++]) == '.') ? FTokenContext.KWOP_GE
0832: : null;
0833: case 't': // gt
0834: return (len == 4 && Character
0835: .toLowerCase(buffer[offset++]) == '.') ? FTokenContext.KWOP_GT
0836: : null;
0837: default:
0838: return null;
0839: }
0840:
0841: case 'l': // le, lt
0842: switch (Character.toLowerCase(buffer[offset++])) {
0843: case 'e': // le
0844: return (len == 4 && Character
0845: .toLowerCase(buffer[offset++]) == '.') ? FTokenContext.KWOP_LE
0846: : null;
0847: case 't': // lt
0848: return (len == 4 && Character
0849: .toLowerCase(buffer[offset++]) == '.') ? FTokenContext.KWOP_LT
0850: : null;
0851: default:
0852: return null;
0853: }
0854:
0855: case 'n': // ne, neqv, not
0856: switch (Character.toLowerCase(buffer[offset++])) {
0857: case 'e': // ne
0858: if (len == 4
0859: && Character.toLowerCase(buffer[offset++]) == '.')
0860: return FTokenContext.KWOP_NE;
0861: else if (len == 6
0862: && Character.toLowerCase(buffer[offset++]) == 'q'
0863: && Character.toLowerCase(buffer[offset++]) == 'v'
0864: && Character.toLowerCase(buffer[offset++]) == '.')
0865: return FTokenContext.KWOP_NEQV;
0866: else
0867: return null;
0868: case 'o': // not
0869: return (len == 5
0870: && Character.toLowerCase(buffer[offset++]) == 't' && Character
0871: .toLowerCase(buffer[offset++]) == '.') ? FTokenContext.KWOP_NOT
0872: : null;
0873: default:
0874: return null;
0875: }
0876:
0877: case 'o': // .or.
0878: return (len == 4
0879: && Character.toLowerCase(buffer[offset++]) == 'r' && Character
0880: .toLowerCase(buffer[offset++]) == '.') ? FTokenContext.KWOP_OR
0881: : null;
0882:
0883: case 't': // .true.
0884: return (len == 6
0885: && Character.toLowerCase(buffer[offset++]) == 'r'
0886: && Character.toLowerCase(buffer[offset++]) == 'u'
0887: && Character.toLowerCase(buffer[offset++]) == 'e' && Character
0888: .toLowerCase(buffer[offset++]) == '.') ? FTokenContext.KWOP_OR
0889: : null;
0890: default:
0891: return null;
0892: }//switch dot
0893: //END DOT
0894:
0895: //A
0896: //access= action= advance= allocatable allocate apostrophe assignment
0897: case 'a':
0898: if ((len < 7) || (len > 11))
0899: return null;
0900:
0901: switch (Character.toLowerCase(buffer[offset++])) {
0902: case 'c': //access= action=
0903: switch (Character.toLowerCase(buffer[offset++])) {
0904: case 'c': // access=
0905: return (len == 7
0906: && Character.toLowerCase(buffer[offset++]) == 'e'
0907: && Character.toLowerCase(buffer[offset++]) == 's'
0908: && Character.toLowerCase(buffer[offset++]) == 's' && Character
0909: .toLowerCase(buffer[offset++]) == '=') ? FTokenContext.KW_ACCESS_EQ
0910: : null;
0911: case 't': //action=
0912: return (len == 7
0913: && Character.toLowerCase(buffer[offset++]) == 'i'
0914: && Character.toLowerCase(buffer[offset++]) == 'o'
0915: && Character.toLowerCase(buffer[offset++]) == 'n' && Character
0916: .toLowerCase(buffer[offset++]) == '=') ? FTokenContext.KW_ACTION_EQ
0917: : null;
0918: default:
0919: return null;
0920: }//switch ac
0921:
0922: case 'd': // advance=
0923: return (len == 8
0924: && Character.toLowerCase(buffer[offset++]) == 'v'
0925: && Character.toLowerCase(buffer[offset++]) == 'a'
0926: && Character.toLowerCase(buffer[offset++]) == 'n'
0927: && Character.toLowerCase(buffer[offset++]) == 'c'
0928: && Character.toLowerCase(buffer[offset++]) == 'e' && Character
0929: .toLowerCase(buffer[offset++]) == '=') ? FTokenContext.KW_ADVANCE_EQ
0930: : null;
0931:
0932: case 'l': // allocatable allocate
0933: if (len >= 8
0934: && Character.toLowerCase(buffer[offset++]) == 'l'
0935: && Character.toLowerCase(buffer[offset++]) == 'o'
0936: && Character.toLowerCase(buffer[offset++]) == 'c'
0937: && Character.toLowerCase(buffer[offset++]) == 'a'
0938: && Character.toLowerCase(buffer[offset++]) == 't') {
0939:
0940: if (len == 11
0941: && Character.toLowerCase(buffer[offset++]) == 'a'
0942: && Character.toLowerCase(buffer[offset++]) == 'b'
0943: && Character.toLowerCase(buffer[offset++]) == 'l'
0944: && Character.toLowerCase(buffer[offset++]) == 'e')
0945: return FTokenContext.KW_ALLOCATABLE;
0946: else if (len == 8
0947: && Character.toLowerCase(buffer[offset++]) == 'e')
0948: return FTokenContext.KW_ALLOCATE;
0949: else
0950: return null;
0951: } else {
0952: return null;
0953: }
0954:
0955: case 'p': // apostrophe
0956: return (len == 10
0957: && Character.toLowerCase(buffer[offset++]) == 'o'
0958: && Character.toLowerCase(buffer[offset++]) == 's'
0959: && Character.toLowerCase(buffer[offset++]) == 't'
0960: && Character.toLowerCase(buffer[offset++]) == 'r'
0961: && Character.toLowerCase(buffer[offset++]) == 'o'
0962: && Character.toLowerCase(buffer[offset++]) == 'p'
0963: && Character.toLowerCase(buffer[offset++]) == 'h' && Character
0964: .toLowerCase(buffer[offset++]) == 'e') ? FTokenContext.KW_APOSTROPHE
0965: : null;
0966:
0967: case 's': // assignment
0968: return (len == 10
0969: && Character.toLowerCase(buffer[offset++]) == 's'
0970: && Character.toLowerCase(buffer[offset++]) == 'i'
0971: && Character.toLowerCase(buffer[offset++]) == 'g'
0972: && Character.toLowerCase(buffer[offset++]) == 'n'
0973: && Character.toLowerCase(buffer[offset++]) == 'm'
0974: && Character.toLowerCase(buffer[offset++]) == 'e'
0975: && Character.toLowerCase(buffer[offset++]) == 'n' && Character
0976: .toLowerCase(buffer[offset++]) == 't') ? FTokenContext.KW_ASSIGNMENT
0977: : null;
0978:
0979: default:
0980: return null;
0981: }//switch a
0982: //END A
0983:
0984: //B
0985: //backspace blank= block blockdata
0986: case 'b':
0987: if ((len < 5) || (len > 9))
0988: return null;
0989:
0990: switch (Character.toLowerCase(buffer[offset++])) {
0991: case 'a': // backspace
0992: return (len == 9
0993: && Character.toLowerCase(buffer[offset++]) == 'c'
0994: && Character.toLowerCase(buffer[offset++]) == 'k'
0995: && Character.toLowerCase(buffer[offset++]) == 's'
0996: && Character.toLowerCase(buffer[offset++]) == 'p'
0997: && Character.toLowerCase(buffer[offset++]) == 'a'
0998: && Character.toLowerCase(buffer[offset++]) == 'c' && Character
0999: .toLowerCase(buffer[offset++]) == 'e') ? FTokenContext.KW_BACKSPACE
1000: : null;
1001:
1002: case 'l': // blank= block blockdata
1003: switch (Character.toLowerCase(buffer[offset++])) {
1004: case 'a': //blank=
1005: return (len == 6
1006: && Character.toLowerCase(buffer[offset++]) == 'n'
1007: && Character.toLowerCase(buffer[offset++]) == 'k' && Character
1008: .toLowerCase(buffer[offset++]) == '=') ? FTokenContext.KW_BLANK_EQ
1009: : null;
1010:
1011: case 'o': //block blockdata
1012: if (len >= 5
1013: && Character.toLowerCase(buffer[offset++]) == 'c'
1014: && Character.toLowerCase(buffer[offset++]) == 'k') {
1015:
1016: if (len == 5)
1017: return FTokenContext.KW_BLOCK;
1018: else if (len == 9
1019: && Character
1020: .toLowerCase(buffer[offset++]) == 'd'
1021: && Character
1022: .toLowerCase(buffer[offset++]) == 'a'
1023: && Character
1024: .toLowerCase(buffer[offset++]) == 't'
1025: && Character
1026: .toLowerCase(buffer[offset++]) == 'a')
1027: return FTokenContext.KW_BLOCKDATA;
1028: else
1029: return null;
1030: }
1031:
1032: else {
1033: return null;
1034: }
1035:
1036: default:
1037: return null;
1038: }//switch l
1039:
1040: default:
1041: return null;
1042: }//switch b
1043: //END B
1044:
1045: //C
1046: //case character close common complex contains continue cycle
1047: case 'c':
1048: if ((len < 4) || (len > 9))
1049: return null;
1050:
1051: switch (Character.toLowerCase(buffer[offset++])) {
1052: case 'a': // case or call
1053: switch (Character.toLowerCase(buffer[offset++])) {
1054: case 'l': // call
1055: return (len == 4 && Character
1056: .toLowerCase(buffer[offset++]) == 'l') ? FTokenContext.KW_CALL
1057: : null;
1058:
1059: case 's': // case
1060: return (len == 4 && Character
1061: .toLowerCase(buffer[offset++]) == 'e') ? FTokenContext.KW_CASE
1062: : null;
1063:
1064: default:
1065: return null;
1066: }
1067: case 'h': // character
1068: return (len == 9
1069: && Character.toLowerCase(buffer[offset++]) == 'a'
1070: && Character.toLowerCase(buffer[offset++]) == 'r'
1071: && Character.toLowerCase(buffer[offset++]) == 'a'
1072: && Character.toLowerCase(buffer[offset++]) == 'c'
1073: && Character.toLowerCase(buffer[offset++]) == 't'
1074: && Character.toLowerCase(buffer[offset++]) == 'e' && Character
1075: .toLowerCase(buffer[offset++]) == 'r') ? FTokenContext.KW_CHARACTER
1076: : null;
1077:
1078: case 'l': // close
1079: return (len == 5
1080: && Character.toLowerCase(buffer[offset++]) == 'o'
1081: && Character.toLowerCase(buffer[offset++]) == 's' && Character
1082: .toLowerCase(buffer[offset++]) == 'e') ? FTokenContext.KW_CLOSE
1083: : null;
1084:
1085: case 'o': // common, complex, contains, continue
1086: switch (Character.toLowerCase(buffer[offset++])) {
1087: case 'm': // common, complex
1088: switch (Character.toLowerCase(buffer[offset++])) {
1089: case 'm': // common
1090: return (len == 6
1091: && Character
1092: .toLowerCase(buffer[offset++]) == 'o' && Character
1093: .toLowerCase(buffer[offset++]) == 'n') ? FTokenContext.KW_COMMON
1094: : null;
1095: case 'p': // complex
1096: return (len == 7
1097: && Character
1098: .toLowerCase(buffer[offset++]) == 'l'
1099: && Character
1100: .toLowerCase(buffer[offset++]) == 'e' && Character
1101: .toLowerCase(buffer[offset++]) == 'x') ? FTokenContext.KW_COMPLEX
1102: : null;
1103: default:
1104: return null;
1105: } //switch com
1106:
1107: case 'n': // contains continue
1108: if (len == 8
1109: && Character.toLowerCase(buffer[offset++]) == 't') {
1110: switch (Character.toLowerCase(buffer[offset++])) {
1111: case 'a': // contains
1112: return (len == 8
1113: && Character
1114: .toLowerCase(buffer[offset++]) == 'i'
1115: && Character
1116: .toLowerCase(buffer[offset++]) == 'n' && Character
1117: .toLowerCase(buffer[offset++]) == 's') ? FTokenContext.KW_CONTAINS
1118: : null;
1119: case 'i': //continue
1120: return (len == 8
1121: && Character
1122: .toLowerCase(buffer[offset++]) == 'n'
1123: && Character
1124: .toLowerCase(buffer[offset++]) == 'u' && Character
1125: .toLowerCase(buffer[offset++]) == 'e') ? FTokenContext.KW_CONTINUE
1126: : null;
1127: default:
1128: return null;
1129: }//switch cont
1130: }//if
1131: else
1132: return null;
1133:
1134: default:
1135: return null;
1136: } //switch co
1137:
1138: case 'y': // cycle
1139: return (len == 5
1140: && Character.toLowerCase(buffer[offset++]) == 'c'
1141: && Character.toLowerCase(buffer[offset++]) == 'l' && Character
1142: .toLowerCase(buffer[offset++]) == 'e') ? FTokenContext.KW_CYCLE
1143: : null;
1144:
1145: default:
1146: return null;
1147: } //switch c
1148: //END C
1149:
1150: //D
1151: //data deallocate default delim= dimension direct= do double doubleprecision
1152: case 'd':
1153: if ((len < 2) || (len > 15))
1154: return null;
1155:
1156: switch (Character.toLowerCase(buffer[offset++])) {
1157: case 'a': // data
1158: return (len == 4
1159: && Character.toLowerCase(buffer[offset++]) == 't' && Character
1160: .toLowerCase(buffer[offset++]) == 'a') ? FTokenContext.KW_DATA
1161: : null;
1162:
1163: case 'e': // deallocate default delim=
1164: switch (Character.toLowerCase(buffer[offset++])) {
1165: case 'a': // deallocate
1166: return (len == 10
1167: && Character.toLowerCase(buffer[offset++]) == 'l'
1168: && Character.toLowerCase(buffer[offset++]) == 'l'
1169: && Character.toLowerCase(buffer[offset++]) == 'o'
1170: && Character.toLowerCase(buffer[offset++]) == 'c'
1171: && Character.toLowerCase(buffer[offset++]) == 'a'
1172: && Character.toLowerCase(buffer[offset++]) == 't' && Character
1173: .toLowerCase(buffer[offset++]) == 'e') ? FTokenContext.KW_DEALLOCATE
1174: : null;
1175: case 'f': // default
1176: return (len == 7
1177: && Character.toLowerCase(buffer[offset++]) == 'a'
1178: && Character.toLowerCase(buffer[offset++]) == 'u'
1179: && Character.toLowerCase(buffer[offset++]) == 'l' && Character
1180: .toLowerCase(buffer[offset++]) == 't') ? FTokenContext.KW_DEFAULT
1181: : null;
1182: case 'l': // delim=
1183: return (len == 6
1184: && Character.toLowerCase(buffer[offset++]) == 'i'
1185: && Character.toLowerCase(buffer[offset++]) == 'm' && Character
1186: .toLowerCase(buffer[offset++]) == '=') ? FTokenContext.KW_DELIM_EQ
1187: : null;
1188: default:
1189: return null;
1190: } //switch de
1191:
1192: case 'i': // dimension direct=
1193: switch (Character.toLowerCase(buffer[offset++])) {
1194: case 'm': // dimension
1195: return (len == 9
1196: && Character.toLowerCase(buffer[offset++]) == 'e'
1197: && Character.toLowerCase(buffer[offset++]) == 'n'
1198: && Character.toLowerCase(buffer[offset++]) == 's'
1199: && Character.toLowerCase(buffer[offset++]) == 'i'
1200: && Character.toLowerCase(buffer[offset++]) == 'o' && Character
1201: .toLowerCase(buffer[offset++]) == 'n') ? FTokenContext.KW_DIMENSION
1202: : null;
1203: case 'r': // direct=
1204: return (len == 7
1205: && Character.toLowerCase(buffer[offset++]) == 'e'
1206: && Character.toLowerCase(buffer[offset++]) == 'c'
1207: && Character.toLowerCase(buffer[offset++]) == 't' && Character
1208: .toLowerCase(buffer[offset++]) == '=') ? FTokenContext.KW_DIRECT_EQ
1209: : null;
1210: default:
1211: return null;
1212: } //switch di
1213:
1214: case 'o': // do, double, doubleprecision
1215: if (len == 2)
1216: return FTokenContext.KW_DO;
1217:
1218: else if (len >= 6
1219: && Character.toLowerCase(buffer[offset++]) == 'u'
1220: && Character.toLowerCase(buffer[offset++]) == 'b'
1221: && Character.toLowerCase(buffer[offset++]) == 'l'
1222: && Character.toLowerCase(buffer[offset++]) == 'e') {
1223: if (len == 6)
1224: return FTokenContext.KW_DOUBLE;
1225: else if (len == 15
1226: && Character.toLowerCase(buffer[offset++]) == 'p'
1227: && Character.toLowerCase(buffer[offset++]) == 'r'
1228: && Character.toLowerCase(buffer[offset++]) == 'e'
1229: && Character.toLowerCase(buffer[offset++]) == 'c'
1230: && Character.toLowerCase(buffer[offset++]) == 'i'
1231: && Character.toLowerCase(buffer[offset++]) == 's'
1232: && Character.toLowerCase(buffer[offset++]) == 'i'
1233: && Character.toLowerCase(buffer[offset++]) == 'o'
1234: && Character.toLowerCase(buffer[offset++]) == 'n')
1235: return FTokenContext.KW_DOUBLEPRECISION;
1236: else
1237: return null;
1238: } else
1239: return null;
1240:
1241: default:
1242: return null;
1243: }//switch d
1244: //END D
1245:
1246: //E
1247: //elemental else elseif elsewhere end endblock endblockdata enddo end=
1248: //endfile endforall endfunction endif endinterface endmodule endprogram
1249: //endselect endsubroutine endtype endwhere entry eor= equivalance err=
1250: //exist= exit external
1251: case 'e':
1252: if ((len < 3) || (len > 13))
1253: return null;
1254:
1255: switch (Character.toLowerCase(buffer[offset++])) {
1256: case 'l': // elemental else elseif elsewhere
1257: switch (Character.toLowerCase(buffer[offset++])) {
1258: case 'e'://elemental
1259: return (len == 9
1260: && Character.toLowerCase(buffer[offset++]) == 'm'
1261: && Character.toLowerCase(buffer[offset++]) == 'e'
1262: && Character.toLowerCase(buffer[offset++]) == 'n'
1263: && Character.toLowerCase(buffer[offset++]) == 't'
1264: && Character.toLowerCase(buffer[offset++]) == 'a' && Character
1265: .toLowerCase(buffer[offset++]) == 'l') ? FTokenContext.KW_ELEMENTAL
1266: : null;
1267: case 's': //else elseif elsewhere
1268: if (len >= 4
1269: && Character.toLowerCase(buffer[offset++]) == 'e') {
1270: if (len == 4)
1271: return FTokenContext.KW_ELSE;
1272: else if (len == 6
1273: && Character
1274: .toLowerCase(buffer[offset++]) == 'i'
1275: && Character
1276: .toLowerCase(buffer[offset++]) == 'f')
1277: return FTokenContext.KW_ELSEIF;
1278: else if (len == 9
1279: && Character
1280: .toLowerCase(buffer[offset++]) == 'w'
1281: && Character
1282: .toLowerCase(buffer[offset++]) == 'h'
1283: && Character
1284: .toLowerCase(buffer[offset++]) == 'e'
1285: && Character
1286: .toLowerCase(buffer[offset++]) == 'r'
1287: && Character
1288: .toLowerCase(buffer[offset++]) == 'e')
1289: return FTokenContext.KW_ELSEWHERE;
1290: else
1291: return null;
1292:
1293: } else
1294: return null;
1295:
1296: default:
1297: return null;
1298: } //switch el
1299:
1300: case 'n': // end end[*] entry
1301: switch (Character.toLowerCase(buffer[offset++])) {
1302: case 'd': // end end[*]
1303: //BEGIN "END"
1304: if (len == 3)
1305: return FTokenContext.KW_END;
1306: switch (Character.toLowerCase(buffer[offset++])) {
1307: case '=': // end=
1308: return (len == 4) ? FTokenContext.KW_END_EQ
1309: : null;
1310:
1311: case 'b': //endblock endblockdata
1312: if (len >= 8
1313: && Character
1314: .toLowerCase(buffer[offset++]) == 'l'
1315: && Character
1316: .toLowerCase(buffer[offset++]) == 'o'
1317: && Character
1318: .toLowerCase(buffer[offset++]) == 'c'
1319: && Character
1320: .toLowerCase(buffer[offset++]) == 'k') {
1321:
1322: if (len == 8)
1323: return FTokenContext.KW_ENDBLOCK;
1324: else if (len == 12
1325: && Character
1326: .toLowerCase(buffer[offset++]) == 'd'
1327: && Character
1328: .toLowerCase(buffer[offset++]) == 'a'
1329: && Character
1330: .toLowerCase(buffer[offset++]) == 't'
1331: && Character
1332: .toLowerCase(buffer[offset++]) == 'a')
1333: return FTokenContext.KW_ENDBLOCKDATA;
1334: else
1335: return null;
1336: } else
1337: return null;
1338:
1339: case 'd': // enddo
1340: return (len == 5 && Character
1341: .toLowerCase(buffer[offset++]) == 'o') ? FTokenContext.KW_ENDDO
1342: : null;
1343:
1344: case 'f': //endfile endforall endfunction
1345: switch (Character.toLowerCase(buffer[offset++])) {
1346: case 'i'://endfile
1347: return (len == 7
1348: && Character
1349: .toLowerCase(buffer[offset++]) == 'l' && Character
1350: .toLowerCase(buffer[offset++]) == 'e') ? FTokenContext.KW_ENDFILE
1351: : null;
1352: case 'o': //endforall
1353: return (len == 9
1354: && Character
1355: .toLowerCase(buffer[offset++]) == 'r'
1356: && Character
1357: .toLowerCase(buffer[offset++]) == 'a'
1358: && Character
1359: .toLowerCase(buffer[offset++]) == 'l' && Character
1360: .toLowerCase(buffer[offset++]) == 'l') ? FTokenContext.KW_ENDFORALL
1361: : null;
1362: case 'u': //endfunction
1363: return (len == 11
1364: && Character
1365: .toLowerCase(buffer[offset++]) == 'n'
1366: && Character
1367: .toLowerCase(buffer[offset++]) == 'c'
1368: && Character
1369: .toLowerCase(buffer[offset++]) == 't'
1370: && Character
1371: .toLowerCase(buffer[offset++]) == 'i'
1372: && Character
1373: .toLowerCase(buffer[offset++]) == 'o' && Character
1374: .toLowerCase(buffer[offset++]) == 'n') ? FTokenContext.KW_ENDFUNCTION
1375: : null;
1376: default:
1377: return null;
1378: } //switch endf
1379:
1380: case 'i': // endif endinterface
1381: switch (Character.toLowerCase(buffer[offset++])) {
1382: case 'f'://endif
1383: return (len == 5) ? FTokenContext.KW_ENDIF
1384: : null;
1385: case 'n': //endinterface
1386: return (len == 12
1387: && Character
1388: .toLowerCase(buffer[offset++]) == 't'
1389: && Character
1390: .toLowerCase(buffer[offset++]) == 'e'
1391: && Character
1392: .toLowerCase(buffer[offset++]) == 'r'
1393: && Character
1394: .toLowerCase(buffer[offset++]) == 'f'
1395: && Character
1396: .toLowerCase(buffer[offset++]) == 'a'
1397: && Character
1398: .toLowerCase(buffer[offset++]) == 'c' && Character
1399: .toLowerCase(buffer[offset++]) == 'e') ? FTokenContext.KW_ENDINTERFACE
1400: : null;
1401: default:
1402: return null;
1403: } //switch endi
1404:
1405: case 'm':
1406: switch (Character.toLowerCase(buffer[offset++])) {
1407: case 'a': // endmap
1408: return (len == 6 && Character
1409: .toLowerCase(buffer[offset++]) == 'p') ? FTokenContext.KW_ENDMAP
1410: : null;
1411:
1412: case 'o': // endmodule
1413: return (len == 9
1414: && Character
1415: .toLowerCase(buffer[offset++]) == 'd'
1416: && Character
1417: .toLowerCase(buffer[offset++]) == 'u'
1418: && Character
1419: .toLowerCase(buffer[offset++]) == 'l' && Character
1420: .toLowerCase(buffer[offset++]) == 'e') ? FTokenContext.KW_ENDMODULE
1421: : null;
1422: default:
1423: return null;
1424: }
1425:
1426: case 'p': // endprogram
1427: return (len == 10
1428: && Character
1429: .toLowerCase(buffer[offset++]) == 'r'
1430: && Character
1431: .toLowerCase(buffer[offset++]) == 'o'
1432: && Character
1433: .toLowerCase(buffer[offset++]) == 'g'
1434: && Character
1435: .toLowerCase(buffer[offset++]) == 'r'
1436: && Character
1437: .toLowerCase(buffer[offset++]) == 'a' && Character
1438: .toLowerCase(buffer[offset++]) == 'm') ? FTokenContext.KW_ENDPROGRAM
1439: : null;
1440:
1441: case 's': // endselect endsubroutine
1442: switch (Character.toLowerCase(buffer[offset++])) {
1443: case 'e'://endselect
1444: return (len == 9
1445: && Character
1446: .toLowerCase(buffer[offset++]) == 'l'
1447: && Character
1448: .toLowerCase(buffer[offset++]) == 'e'
1449: && Character
1450: .toLowerCase(buffer[offset++]) == 'c' && Character
1451: .toLowerCase(buffer[offset++]) == 't') ? FTokenContext.KW_ENDSELECT
1452: : null;
1453: case 't': //endstructure
1454: return (len == 12
1455: && Character
1456: .toLowerCase(buffer[offset++]) == 'r'
1457: && Character
1458: .toLowerCase(buffer[offset++]) == 'u'
1459: && Character
1460: .toLowerCase(buffer[offset++]) == 'c'
1461: && Character
1462: .toLowerCase(buffer[offset++]) == 't'
1463: && Character
1464: .toLowerCase(buffer[offset++]) == 'u'
1465: && Character
1466: .toLowerCase(buffer[offset++]) == 'r' && Character
1467: .toLowerCase(buffer[offset++]) == 'e') ? FTokenContext.KW_ENDSTRUCTURE
1468: : null;
1469: case 'u': //endsubroutine
1470: return (len == 13
1471: && Character
1472: .toLowerCase(buffer[offset++]) == 'b'
1473: && Character
1474: .toLowerCase(buffer[offset++]) == 'r'
1475: && Character
1476: .toLowerCase(buffer[offset++]) == 'o'
1477: && Character
1478: .toLowerCase(buffer[offset++]) == 'u'
1479: && Character
1480: .toLowerCase(buffer[offset++]) == 't'
1481: && Character
1482: .toLowerCase(buffer[offset++]) == 'i'
1483: && Character
1484: .toLowerCase(buffer[offset++]) == 'n' && Character
1485: .toLowerCase(buffer[offset++]) == 'e') ? FTokenContext.KW_ENDSUBROUTINE
1486: : null;
1487: default:
1488: return null;
1489: } //switch "ends"
1490:
1491: case 't': // endtype
1492: return (len == 7
1493: && Character
1494: .toLowerCase(buffer[offset++]) == 'y'
1495: && Character
1496: .toLowerCase(buffer[offset++]) == 'p' && Character
1497: .toLowerCase(buffer[offset++]) == 'e') ? FTokenContext.KW_ENDTYPE
1498: : null;
1499:
1500: case 'u': // endunion
1501: return (len == 8
1502: && Character
1503: .toLowerCase(buffer[offset++]) == 'n'
1504: && Character
1505: .toLowerCase(buffer[offset++]) == 'i'
1506: && Character
1507: .toLowerCase(buffer[offset++]) == 'o' && Character
1508: .toLowerCase(buffer[offset++]) == 'n') ? FTokenContext.KW_ENDUNION
1509: : null;
1510: case 'w': // endwhere
1511: return (len == 8
1512: && Character
1513: .toLowerCase(buffer[offset++]) == 'h'
1514: && Character
1515: .toLowerCase(buffer[offset++]) == 'e'
1516: && Character
1517: .toLowerCase(buffer[offset++]) == 'r' && Character
1518: .toLowerCase(buffer[offset++]) == 'e') ? FTokenContext.KW_ENDWHERE
1519: : null;
1520:
1521: default:
1522: return null;
1523:
1524: } //switch "end"
1525: //END "END"
1526: case 't': // entry
1527: return (len == 5
1528: && Character.toLowerCase(buffer[offset++]) == 'r' && Character
1529: .toLowerCase(buffer[offset++]) == 'y') ? FTokenContext.KW_ENTRY
1530: : null;
1531: default:
1532: return null;
1533: } //switch en
1534:
1535: case 'o': // eor=
1536: return (len == 4
1537: && Character.toLowerCase(buffer[offset++]) == 'r' && Character
1538: .toLowerCase(buffer[offset++]) == '=') ? FTokenContext.KW_EOR_EQ
1539: : null;
1540:
1541: case 'q': // equivalance
1542: return (len == 11
1543: && Character.toLowerCase(buffer[offset++]) == 'u'
1544: && Character.toLowerCase(buffer[offset++]) == 'i'
1545: && Character.toLowerCase(buffer[offset++]) == 'v'
1546: && Character.toLowerCase(buffer[offset++]) == 'a'
1547: && Character.toLowerCase(buffer[offset++]) == 'l'
1548: && Character.toLowerCase(buffer[offset++]) == 'a'
1549: && Character.toLowerCase(buffer[offset++]) == 'n'
1550: && Character.toLowerCase(buffer[offset++]) == 'c' && Character
1551: .toLowerCase(buffer[offset++]) == 'e') ? FTokenContext.KW_EQUIVALENCE
1552: : null;
1553:
1554: case 'r': // err=
1555: return (len == 4
1556: && Character.toLowerCase(buffer[offset++]) == 'r' && Character
1557: .toLowerCase(buffer[offset++]) == '=') ? FTokenContext.KW_ERR_EQ
1558: : null;
1559:
1560: case 'x': // exists=, exit, external
1561: switch (Character.toLowerCase(buffer[offset++])) {
1562: case 'i': // exists=, exit
1563: switch (Character.toLowerCase(buffer[offset++])) {
1564: case 's': //exist=
1565: return (len == 6
1566: && Character
1567: .toLowerCase(buffer[offset++]) == 't' && Character
1568: .toLowerCase(buffer[offset++]) == '=') ? FTokenContext.KW_EXIST_EQ
1569: : null;
1570: case 't': //exit
1571: return (len == 4) ? FTokenContext.KW_EXIT
1572: : null;
1573: default:
1574: return null;
1575: } //switch exi
1576:
1577: case 't': // external
1578: return (len == 8
1579: && Character.toLowerCase(buffer[offset++]) == 'e'
1580: && Character.toLowerCase(buffer[offset++]) == 'r'
1581: && Character.toLowerCase(buffer[offset++]) == 'n'
1582: && Character.toLowerCase(buffer[offset++]) == 'a' && Character
1583: .toLowerCase(buffer[offset++]) == 'l') ? FTokenContext.KW_EXTERNAL
1584: : null;
1585: default:
1586: return null;
1587: }//switch ex
1588: default:
1589: return null;
1590: }//switch e
1591: //END E
1592:
1593: //F
1594: //file file= forall form= format formatted function
1595: case 'f': // format function
1596: if ((len < 4) || (len > 9))
1597: return null;
1598:
1599: switch (Character.toLowerCase(buffer[offset++])) {
1600: case 'i': // file file=
1601: if (len >= 4
1602: && Character.toLowerCase(buffer[offset++]) == 'l'
1603: && Character.toLowerCase(buffer[offset++]) == 'e') {
1604:
1605: if (len == 4)
1606: return FTokenContext.KW_FILE;
1607: else if (len == 5
1608: && Character.toLowerCase(buffer[offset++]) == '=')
1609: return FTokenContext.KW_FILE_EQ;
1610: else
1611: return null;
1612: } else
1613: return null;
1614:
1615: case 'o': // forall form= format formatted
1616: switch (Character.toLowerCase(buffer[offset++])) {
1617: case 'r':
1618: switch (Character.toLowerCase(buffer[offset++])) {
1619: case 'a': //forall
1620: return (len == 6
1621: && Character
1622: .toLowerCase(buffer[offset++]) == 'l' && Character
1623: .toLowerCase(buffer[offset++]) == 'l') ? FTokenContext.KW_FORALL
1624: : null;
1625: case 'm': //form= format formatted
1626: switch (Character.toLowerCase(buffer[offset++])) {
1627: case '=': //form=
1628: return (len == 5) ? FTokenContext.KW_FORM_EQ
1629: : null;
1630: case 'a': //format formatted
1631: if (len >= 6
1632: && Character
1633: .toLowerCase(buffer[offset++]) == 't') {
1634: if (len == 6)
1635: return FTokenContext.KW_FORMAT;
1636: else if (len == 9
1637: && Character
1638: .toLowerCase(buffer[offset++]) == 't'
1639: && Character
1640: .toLowerCase(buffer[offset++]) == 'e'
1641: && Character
1642: .toLowerCase(buffer[offset++]) == 'd')
1643: return FTokenContext.KW_FORMATTED;
1644: else
1645: return null;
1646: } else
1647: return null;
1648: default:
1649: return null;
1650: } //switch form
1651:
1652: default:
1653: return null;
1654: } //switch for
1655: default:
1656: return null;
1657: }//switch fo
1658:
1659: case 'u': // function
1660: return (len == 8
1661: && Character.toLowerCase(buffer[offset++]) == 'n'
1662: && Character.toLowerCase(buffer[offset++]) == 'c'
1663: && Character.toLowerCase(buffer[offset++]) == 't'
1664: && Character.toLowerCase(buffer[offset++]) == 'i'
1665: && Character.toLowerCase(buffer[offset++]) == 'o' && Character
1666: .toLowerCase(buffer[offset++]) == 'n') ? FTokenContext.KW_FUNCTION
1667: : null;
1668:
1669: default:
1670: return null;
1671: }//switch f
1672: //END F
1673:
1674: //G
1675: //go goto
1676: case 'g':
1677: if ((len < 2) || (len > 4))
1678: return null;
1679:
1680: if (len >= 2
1681: && Character.toLowerCase(buffer[offset++]) == 'o') {
1682: if (len == 2)
1683: return FTokenContext.KW_GO;
1684: else if (len == 4
1685: && Character.toLowerCase(buffer[offset++]) == 't'
1686: && Character.toLowerCase(buffer[offset++]) == 'o')
1687: return FTokenContext.KW_GOTO;
1688: else
1689: return null;
1690: } else
1691: return null;
1692: //END G
1693:
1694: //I
1695: //if implicit in include inout inquire integer intent interface intrinsic
1696: //iostat=
1697:
1698: case 'i':
1699: if ((len < 2) || (len > 9))
1700: return null;
1701:
1702: switch (Character.toLowerCase(buffer[offset++])) {
1703: case 'f': // if
1704: return (len == 2) ? FTokenContext.KW_IF : null;
1705:
1706: case 'm': // implicit
1707: return (len == 8
1708: && Character.toLowerCase(buffer[offset++]) == 'p'
1709: && Character.toLowerCase(buffer[offset++]) == 'l'
1710: && Character.toLowerCase(buffer[offset++]) == 'i'
1711: && Character.toLowerCase(buffer[offset++]) == 'c'
1712: && Character.toLowerCase(buffer[offset++]) == 'i' && Character
1713: .toLowerCase(buffer[offset++]) == 't') ? FTokenContext.KW_IMPLICIT
1714: : null;
1715:
1716: case 'n': // in include inout inquire integer intent interface intrinsic
1717: if (len == 2)
1718: return FTokenContext.KW_IN;
1719: switch (Character.toLowerCase(buffer[offset++])) {
1720: case 'c': //include
1721: return (len == 7
1722: && Character.toLowerCase(buffer[offset++]) == 'l'
1723: && Character.toLowerCase(buffer[offset++]) == 'u'
1724: && Character.toLowerCase(buffer[offset++]) == 'd' && Character
1725: .toLowerCase(buffer[offset++]) == 'e') ? FTokenContext.KW_INCLUDE
1726: : null;
1727: case 'o': //inout
1728: return (len == 5
1729: && Character.toLowerCase(buffer[offset++]) == 'u' && Character
1730: .toLowerCase(buffer[offset++]) == 't') ? FTokenContext.KW_INOUT
1731: : null;
1732: case 'q': //inquire
1733: return (len == 7
1734: && Character.toLowerCase(buffer[offset++]) == 'u'
1735: && Character.toLowerCase(buffer[offset++]) == 'i'
1736: && Character.toLowerCase(buffer[offset++]) == 'r' && Character
1737: .toLowerCase(buffer[offset++]) == 'e') ? FTokenContext.KW_INQUIRE
1738: : null;
1739: case 't': // integer intent interface intrinsic
1740: switch (Character.toLowerCase(buffer[offset++])) {
1741: case 'e': //integer intent interface
1742: switch (Character.toLowerCase(buffer[offset++])) {
1743: case 'g': //integer
1744: return (len == 7
1745: && Character
1746: .toLowerCase(buffer[offset++]) == 'e' && Character
1747: .toLowerCase(buffer[offset++]) == 'r') ? FTokenContext.KW_INTEGER
1748: : null;
1749: case 'n': //intent
1750: return (len == 6 && Character
1751: .toLowerCase(buffer[offset++]) == 't') ? FTokenContext.KW_INTENT
1752: : null;
1753: case 'r': //interface
1754: return (len == 9
1755: && Character
1756: .toLowerCase(buffer[offset++]) == 'f'
1757: && Character
1758: .toLowerCase(buffer[offset++]) == 'a'
1759: && Character
1760: .toLowerCase(buffer[offset++]) == 'c' && Character
1761: .toLowerCase(buffer[offset++]) == 'e') ? FTokenContext.KW_INTERFACE
1762: : null;
1763: default:
1764: return null;
1765: } //switch inte
1766: case 'r': // intrinsic
1767: return (len == 9
1768: && Character
1769: .toLowerCase(buffer[offset++]) == 'i'
1770: && Character
1771: .toLowerCase(buffer[offset++]) == 'n'
1772: && Character
1773: .toLowerCase(buffer[offset++]) == 's'
1774: && Character
1775: .toLowerCase(buffer[offset++]) == 'i' && Character
1776: .toLowerCase(buffer[offset++]) == 'c') ? FTokenContext.KW_INTRINSIC
1777: : null;
1778: default:
1779: return null;
1780: } //switch int
1781: default:
1782: return null;
1783: } //switch in
1784:
1785: case 'o': //iostat=
1786: return (len == 7
1787: && Character.toLowerCase(buffer[offset++]) == 's'
1788: && Character.toLowerCase(buffer[offset++]) == 't'
1789: && Character.toLowerCase(buffer[offset++]) == 'a'
1790: && Character.toLowerCase(buffer[offset++]) == 't' && Character
1791: .toLowerCase(buffer[offset++]) == '=') ? FTokenContext.KW_IOSTAT_EQ
1792: : null;
1793:
1794: default:
1795: return null;
1796: } //switch i
1797: //END I
1798:
1799: //K
1800: //kind
1801: case 'k':
1802: return (len == 4
1803: && Character.toLowerCase(buffer[offset++]) == 'i'
1804: && Character.toLowerCase(buffer[offset++]) == 'n' && Character
1805: .toLowerCase(buffer[offset++]) == 'd') ? FTokenContext.KW_KIND
1806: : null;
1807: //END K
1808:
1809: //L
1810: //len logical
1811: case 'l':
1812: if ((len < 3) || (len > 7))
1813: return null;
1814:
1815: switch (Character.toLowerCase(buffer[offset++])) {
1816: case 'e': //len
1817: return (len == 3 && Character
1818: .toLowerCase(buffer[offset++]) == 'n') ? FTokenContext.KW_LEN
1819: : null;
1820: case 'o': //logical
1821: return (len == 7
1822: && Character.toLowerCase(buffer[offset++]) == 'g'
1823: && Character.toLowerCase(buffer[offset++]) == 'i'
1824: && Character.toLowerCase(buffer[offset++]) == 'c'
1825: && Character.toLowerCase(buffer[offset++]) == 'a' && Character
1826: .toLowerCase(buffer[offset++]) == 'l') ? FTokenContext.KW_LOGICAL
1827: : null;
1828: default:
1829: return null;
1830: }//switch l
1831: //END L
1832:
1833: //M
1834: //map module
1835: case 'm':
1836: switch (Character.toLowerCase(buffer[offset++])) {
1837: case 'a': //map
1838: return (len == 3 && Character
1839: .toLowerCase(buffer[offset++]) == 'p') ? FTokenContext.KW_MAP
1840: : null;
1841: case 'o': //module
1842: return (len == 6
1843: && Character.toLowerCase(buffer[offset++]) == 'd'
1844: && Character.toLowerCase(buffer[offset++]) == 'u'
1845: && Character.toLowerCase(buffer[offset++]) == 'l' && Character
1846: .toLowerCase(buffer[offset++]) == 'e') ? FTokenContext.KW_MODULE
1847: : null;
1848: default:
1849: return null;
1850: }
1851: //END M
1852:
1853: //N
1854: //name= named= namelist nextrec nml= none nullify number=
1855: case 'n':
1856: if ((len < 4) || (len > 8))
1857: return null;
1858:
1859: switch (Character.toLowerCase(buffer[offset++])) {
1860: case 'a': // name= named= namelist
1861: if (len >= 5
1862: && Character.toLowerCase(buffer[offset++]) == 'm'
1863: && Character.toLowerCase(buffer[offset++]) == 'e') {
1864: switch (Character.toLowerCase(buffer[offset++])) {
1865: case '=': //name=
1866: return (len == 5) ? FTokenContext.KW_NAME_EQ
1867: : null;
1868: case 'd': //named=
1869: return (len == 6 && Character
1870: .toLowerCase(buffer[offset++]) == '=') ? FTokenContext.KW_NAMED_EQ
1871: : null;
1872: case 'l': //namelist
1873: return (len == 8
1874: && Character
1875: .toLowerCase(buffer[offset++]) == 'i'
1876: && Character
1877: .toLowerCase(buffer[offset++]) == 's' && Character
1878: .toLowerCase(buffer[offset++]) == 't') ? FTokenContext.KW_NAMELIST
1879: : null;
1880: default:
1881: return null;
1882: }//switch na
1883: } else
1884: return null;
1885:
1886: case 'e': // nextrec
1887: return (len == 7
1888: && Character.toLowerCase(buffer[offset++]) == 'x'
1889: && Character.toLowerCase(buffer[offset++]) == 't'
1890: && Character.toLowerCase(buffer[offset++]) == 'r'
1891: && Character.toLowerCase(buffer[offset++]) == 'e' && Character
1892: .toLowerCase(buffer[offset++]) == 'c') ? FTokenContext.KW_NEXTREC
1893: : null;
1894:
1895: case 'm': // nml=
1896: return (len == 4
1897: && Character.toLowerCase(buffer[offset++]) == 'l' && Character
1898: .toLowerCase(buffer[offset++]) == '=') ? FTokenContext.KW_NML_EQ
1899: : null;
1900:
1901: case 'o': // none
1902: return (len == 4
1903: && Character.toLowerCase(buffer[offset++]) == 'n' && Character
1904: .toLowerCase(buffer[offset++]) == 'e') ? FTokenContext.KW_NONE
1905: : null;
1906:
1907: case 'u': // nullify number=
1908: switch (Character.toLowerCase(buffer[offset++])) {
1909: case 'l': //nullify
1910: return (len == 7
1911: && Character.toLowerCase(buffer[offset++]) == 'l'
1912: && Character.toLowerCase(buffer[offset++]) == 'i'
1913: && Character.toLowerCase(buffer[offset++]) == 'f' && Character
1914: .toLowerCase(buffer[offset++]) == 'y') ? FTokenContext.KW_NULLIFY
1915: : null;
1916: case 'm': //number=
1917: return (len == 7
1918: && Character.toLowerCase(buffer[offset++]) == 'b'
1919: && Character.toLowerCase(buffer[offset++]) == 'e'
1920: && Character.toLowerCase(buffer[offset++]) == 'r' && Character
1921: .toLowerCase(buffer[offset++]) == '=') ? FTokenContext.KW_NUMBER_EQ
1922: : null;
1923: default:
1924: return null;
1925: }//switch nu
1926:
1927: default:
1928: return null;
1929: }//switch n
1930: //END N
1931:
1932: //O
1933: //only open opened= operator optional out
1934: case 'o':
1935: if ((len < 3) || (len > 8))
1936: return null;
1937:
1938: switch (Character.toLowerCase(buffer[offset++])) {
1939: case 'n': // only
1940: return (len == 4
1941: && Character.toLowerCase(buffer[offset++]) == 'l' && Character
1942: .toLowerCase(buffer[offset++]) == 'y') ? FTokenContext.KW_ONLY
1943: : null;
1944:
1945: case 'p': // open opened= operator optional
1946: switch (Character.toLowerCase(buffer[offset++])) {
1947: case 'e': // open opened= operator
1948: switch (Character.toLowerCase(buffer[offset++])) {
1949: case 'n': //open opened=
1950: if (len == 4)
1951: return FTokenContext.KW_OPEN;
1952: else if (len == 7 //opened=
1953: && Character
1954: .toLowerCase(buffer[offset++]) == 'e'
1955: && Character
1956: .toLowerCase(buffer[offset++]) == 'd'
1957: && Character
1958: .toLowerCase(buffer[offset++]) == '=')
1959: return FTokenContext.KW_OPENED_EQ;
1960: else
1961: return null;
1962: case 'r': //operator
1963: return (len == 8
1964: && Character
1965: .toLowerCase(buffer[offset++]) == 'a'
1966: && Character
1967: .toLowerCase(buffer[offset++]) == 't'
1968: && Character
1969: .toLowerCase(buffer[offset++]) == 'o' && Character
1970: .toLowerCase(buffer[offset++]) == 'r') ? FTokenContext.KW_OPERATOR
1971: : null;
1972: default:
1973: return null;
1974: } //switch ope
1975: case 't': // optional
1976: return (len == 8
1977: && Character.toLowerCase(buffer[offset++]) == 'i'
1978: && Character.toLowerCase(buffer[offset++]) == 'o'
1979: && Character.toLowerCase(buffer[offset++]) == 'n'
1980: && Character.toLowerCase(buffer[offset++]) == 'a' && Character
1981: .toLowerCase(buffer[offset++]) == 'l') ? FTokenContext.KW_OPTIONAL
1982: : null;
1983: default:
1984: return null;
1985: }//switch op
1986:
1987: case 'u': // out
1988: return (len == 3 && Character
1989: .toLowerCase(buffer[offset++]) == 't') ? FTokenContext.KW_OUT
1990: : null;
1991: default:
1992: return null;
1993: } //switch o
1994: //END O
1995:
1996: //P
1997: //pad= parameter pointer position= precision print private procedure
1998: //program public pure
1999: case 'p':
2000: if ((len < 4) || (len > 9))
2001: return null;
2002:
2003: switch (Character.toLowerCase(buffer[offset++])) {
2004: case 'a': // pad= parameter
2005: switch (Character.toLowerCase(buffer[offset++])) {
2006: case 'd': // pad=
2007: return (len == 4 && Character
2008: .toLowerCase(buffer[offset++]) == '=') ? FTokenContext.KW_PAD_EQ
2009: : null;
2010: case 'r': // parameter
2011: return (len == 9
2012: && Character.toLowerCase(buffer[offset++]) == 'a'
2013: && Character.toLowerCase(buffer[offset++]) == 'm'
2014: && Character.toLowerCase(buffer[offset++]) == 'e'
2015: && Character.toLowerCase(buffer[offset++]) == 't'
2016: && Character.toLowerCase(buffer[offset++]) == 'e' && Character
2017: .toLowerCase(buffer[offset++]) == 'r') ? FTokenContext.KW_PARAMETER
2018: : null;
2019: default:
2020: return null;
2021: }//switch pa
2022:
2023: case 'o': // pointer position=
2024: switch (Character.toLowerCase(buffer[offset++])) {
2025: case 'i': // pointer
2026: return (len == 7
2027: && Character.toLowerCase(buffer[offset++]) == 'n'
2028: && Character.toLowerCase(buffer[offset++]) == 't'
2029: && Character.toLowerCase(buffer[offset++]) == 'e' && Character
2030: .toLowerCase(buffer[offset++]) == 'r') ? FTokenContext.KW_POINTER
2031: : null;
2032: case 's': // position=
2033: return (len == 9
2034: && Character.toLowerCase(buffer[offset++]) == 'i'
2035: && Character.toLowerCase(buffer[offset++]) == 't'
2036: && Character.toLowerCase(buffer[offset++]) == 'i'
2037: && Character.toLowerCase(buffer[offset++]) == 'o'
2038: && Character.toLowerCase(buffer[offset++]) == 'n' && Character
2039: .toLowerCase(buffer[offset++]) == '=') ? FTokenContext.KW_POSITION_EQ
2040: : null;
2041: default:
2042: return null;
2043: }//switch po
2044:
2045: case 'r': // precision print private procedure program
2046: switch (Character.toLowerCase(buffer[offset++])) {
2047: case 'e': // precision
2048: return (len == 9
2049: && Character.toLowerCase(buffer[offset++]) == 'c'
2050: && Character.toLowerCase(buffer[offset++]) == 'i'
2051: && Character.toLowerCase(buffer[offset++]) == 's'
2052: && Character.toLowerCase(buffer[offset++]) == 'i'
2053: && Character.toLowerCase(buffer[offset++]) == 'o' && Character
2054: .toLowerCase(buffer[offset++]) == 'n') ? FTokenContext.KW_PRECISION
2055: : null;
2056: case 'i': // print private
2057: switch (Character.toLowerCase(buffer[offset++])) {
2058: case 'n': //print
2059: return (len == 5 && Character
2060: .toLowerCase(buffer[offset++]) == 't') ? FTokenContext.KW_PRINT
2061: : null;
2062: case 'v': //private
2063: return (len == 7
2064: && Character
2065: .toLowerCase(buffer[offset++]) == 'a'
2066: && Character
2067: .toLowerCase(buffer[offset++]) == 't' && Character
2068: .toLowerCase(buffer[offset++]) == 'e') ? FTokenContext.KW_PRIVATE
2069: : null;
2070: default:
2071: return null;
2072: } //switch pri
2073: case 'o': // procedure program
2074: switch (Character.toLowerCase(buffer[offset++])) {
2075: case 'c'://procedure
2076: return (len == 9
2077: && Character
2078: .toLowerCase(buffer[offset++]) == 'e'
2079: && Character
2080: .toLowerCase(buffer[offset++]) == 'd'
2081: && Character
2082: .toLowerCase(buffer[offset++]) == 'u'
2083: && Character
2084: .toLowerCase(buffer[offset++]) == 'r' && Character
2085: .toLowerCase(buffer[offset++]) == 'e') ? FTokenContext.KW_PROCEDURE
2086: : null;
2087: case 'g': //program
2088: return (len == 7
2089: && Character
2090: .toLowerCase(buffer[offset++]) == 'r'
2091: && Character
2092: .toLowerCase(buffer[offset++]) == 'a' && Character
2093: .toLowerCase(buffer[offset++]) == 'm') ? FTokenContext.KW_PROGRAM
2094: : null;
2095: default:
2096: return null;
2097: } //switch pro
2098: default:
2099: return null;
2100: } //switch pr
2101:
2102: case 'u': // public pure
2103: switch (Character.toLowerCase(buffer[offset++])) {
2104: case 'b': // public
2105: return (len == 6
2106: && Character.toLowerCase(buffer[offset++]) == 'l'
2107: && Character.toLowerCase(buffer[offset++]) == 'i' && Character
2108: .toLowerCase(buffer[offset++]) == 'c') ? FTokenContext.KW_PUBLIC
2109: : null;
2110: case 'r': // pure
2111: return (len == 4 && Character
2112: .toLowerCase(buffer[offset++]) == 'e') ? FTokenContext.KW_PURE
2113: : null;
2114: default:
2115: return null;
2116: }//switch pu
2117:
2118: default:
2119: return null;
2120: } //switch p
2121: //END P
2122:
2123: //Q
2124: //quote
2125: case 'q':
2126: return (len == 5
2127: && Character.toLowerCase(buffer[offset++]) == 'u'
2128: && Character.toLowerCase(buffer[offset++]) == 'o'
2129: && Character.toLowerCase(buffer[offset++]) == 't' && Character
2130: .toLowerCase(buffer[offset++]) == 'e') ? FTokenContext.KW_QUOTE
2131: : null;
2132: //END Q
2133:
2134: //R
2135: //read read= readwrite= real rec= recl= recursive result return rewind
2136: case 'r':
2137: if ((len < 4) || (len > 10))
2138: return null;
2139:
2140: if (Character.toLowerCase(buffer[offset++]) != 'e') {
2141: return null;
2142: }
2143:
2144: switch (Character.toLowerCase(buffer[offset++])) {
2145: case 'a': // read read= readwrite= real
2146: switch (Character.toLowerCase(buffer[offset++])) {
2147: case 'd': // read
2148: if (len == 4)
2149: return FTokenContext.KW_READ;
2150: switch (Character.toLowerCase(buffer[offset++])) {
2151: case '=': // read=
2152: return (len == 5) ? FTokenContext.KW_READ_EQ
2153: : null;
2154: case 'w': //readwrite=
2155: return (len == 10
2156: && Character
2157: .toLowerCase(buffer[offset++]) == 'r'
2158: && Character
2159: .toLowerCase(buffer[offset++]) == 'i'
2160: && Character
2161: .toLowerCase(buffer[offset++]) == 't'
2162: && Character
2163: .toLowerCase(buffer[offset++]) == 'e' && Character
2164: .toLowerCase(buffer[offset++]) == '=') ? FTokenContext.KW_READWRITE_EQ
2165: : null;
2166: default:
2167: return null;
2168: } //switch read
2169: case 'l': // real
2170: return (len == 4) ? FTokenContext.KW_REAL : null;
2171: default:
2172: return null;
2173: }//switch rea
2174:
2175: case 'c': // rec= recl= recursive
2176: switch (Character.toLowerCase(buffer[offset++])) {
2177: case '=': // rec=
2178: return (len == 4) ? FTokenContext.KW_REC_EQ : null;
2179: case 'l': // recl=
2180: return (len == 5 && Character
2181: .toLowerCase(buffer[offset++]) == '=') ? FTokenContext.KW_RECL_EQ
2182: : null;
2183: case 'u': // recursive
2184: return (len == 9
2185: && Character.toLowerCase(buffer[offset++]) == 'r'
2186: && Character.toLowerCase(buffer[offset++]) == 's'
2187: && Character.toLowerCase(buffer[offset++]) == 'i'
2188: && Character.toLowerCase(buffer[offset++]) == 'v' && Character
2189: .toLowerCase(buffer[offset++]) == 'e') ? FTokenContext.KW_RECURSIVE
2190: : null;
2191: default:
2192: return null;
2193: }//switch rec
2194:
2195: case 's': // result
2196: return (len == 6
2197: && Character.toLowerCase(buffer[offset++]) == 'u'
2198: && Character.toLowerCase(buffer[offset++]) == 'l' && Character
2199: .toLowerCase(buffer[offset++]) == 't') ? FTokenContext.KW_RESULT
2200: : null;
2201:
2202: case 't': // return
2203: return (len == 6
2204: && Character.toLowerCase(buffer[offset++]) == 'u'
2205: && Character.toLowerCase(buffer[offset++]) == 'r' && Character
2206: .toLowerCase(buffer[offset++]) == 'n') ? FTokenContext.KW_RETURN
2207: : null;
2208:
2209: case 'w': // rewind
2210: return (len == 6
2211: && Character.toLowerCase(buffer[offset++]) == 'i'
2212: && Character.toLowerCase(buffer[offset++]) == 'n' && Character
2213: .toLowerCase(buffer[offset++]) == 'd') ? FTokenContext.KW_REWIND
2214: : null;
2215:
2216: default:
2217: return null;
2218: } //switch r
2219: //END R
2220:
2221: // S
2222: // save size stop select selectcase sequence sequential= size= stat= status=
2223: // structure subroutine
2224: case 's':
2225: if ((len < 4) || (len > 11))
2226: return null;
2227:
2228: if (len == 4) {
2229: switch (Character.toLowerCase(buffer[offset++])) {
2230: case 'a':// save
2231: return (len == 4
2232: && Character.toLowerCase(buffer[offset++]) == 'v' && Character
2233: .toLowerCase(buffer[offset++]) == 'e') ? FTokenContext.KW_SAVE
2234: : null;
2235:
2236: case 'i':// size
2237: return (len == 4
2238: && Character.toLowerCase(buffer[offset++]) == 'z' && Character
2239: .toLowerCase(buffer[offset++]) == 'e') ? FTokenContext.KW_SIZE
2240: : null;
2241:
2242: case 't': // stop
2243: return (len == 4
2244: && Character.toLowerCase(buffer[offset++]) == 'o' && Character
2245: .toLowerCase(buffer[offset++]) == 'p') ? FTokenContext.KW_STOP
2246: : null;
2247: default:
2248: return null;
2249: }
2250: }
2251: switch (Character.toLowerCase(buffer[offset++])) {
2252: case 'e': // select selectcase sequence sequential=
2253: switch (Character.toLowerCase(buffer[offset++])) {
2254: case 'l': //select selectcase
2255: if (len >= 6
2256: && Character.toLowerCase(buffer[offset++]) == 'e'
2257: && Character.toLowerCase(buffer[offset++]) == 'c'
2258: && Character.toLowerCase(buffer[offset++]) == 't') {
2259: if (len == 6)
2260: return FTokenContext.KW_SELECT;
2261: else if (len == 10
2262: && Character
2263: .toLowerCase(buffer[offset++]) == 'c'
2264: && Character
2265: .toLowerCase(buffer[offset++]) == 'a'
2266: && Character
2267: .toLowerCase(buffer[offset++]) == 's'
2268: && Character
2269: .toLowerCase(buffer[offset++]) == 'e')
2270: return FTokenContext.KW_SELECTCASE;
2271: else
2272: return null;
2273: } else
2274: return null;
2275: case 'q': //sequence sequential=
2276: if (len >= 8
2277: && Character.toLowerCase(buffer[offset++]) == 'u'
2278: && Character.toLowerCase(buffer[offset++]) == 'e'
2279: && Character.toLowerCase(buffer[offset++]) == 'n') {
2280: switch (Character.toLowerCase(buffer[offset++])) {
2281: case 'c': //sequence
2282: return (len == 8 && Character
2283: .toLowerCase(buffer[offset++]) == 'e') ? FTokenContext.KW_SEQUENCE
2284: : null;
2285: case 't': //sequential=
2286: return (len == 11
2287: && Character
2288: .toLowerCase(buffer[offset++]) == 'i'
2289: && Character
2290: .toLowerCase(buffer[offset++]) == 'a'
2291: && Character
2292: .toLowerCase(buffer[offset++]) == 'l' && Character
2293: .toLowerCase(buffer[offset++]) == '=') ? FTokenContext.KW_SEQUENTIAL_EQ
2294: : null;
2295: default:
2296: return null;
2297: } //switch sequen
2298: } else
2299: return null;
2300: default:
2301: return null;
2302: } //switch se
2303:
2304: case 'i': // size=
2305: return (len == 5
2306: && Character.toLowerCase(buffer[offset++]) == 'z'
2307: && Character.toLowerCase(buffer[offset++]) == 'e' && Character
2308: .toLowerCase(buffer[offset++]) == '=') ? FTokenContext.KW_SIZE_EQ
2309: : null;
2310:
2311: case 't': // stat= status= stop
2312: switch (Character.toLowerCase(buffer[offset++])) {
2313: case 'a': // stat= status=
2314: if (len >= 5
2315: && Character.toLowerCase(buffer[offset++]) != 't') {
2316: switch (Character.toLowerCase(buffer[offset++])) {
2317: case '=': //stat=
2318: return (len == 5) ? FTokenContext.KW_STAT_EQ
2319: : null;
2320: case 'u': //status=
2321: return (len == 7
2322: && Character
2323: .toLowerCase(buffer[offset++]) == 's' && Character
2324: .toLowerCase(buffer[offset++]) == '=') ? FTokenContext.KW_STATUS_EQ
2325: : null;
2326: default:
2327: return null;
2328: }//switch stat
2329: }//if
2330: else
2331: return null;
2332:
2333: case 'r': // structure
2334: return (len == 9
2335: && Character.toLowerCase(buffer[offset++]) == 'u'
2336: && Character.toLowerCase(buffer[offset++]) == 'c'
2337: && Character.toLowerCase(buffer[offset++]) == 't'
2338: && Character.toLowerCase(buffer[offset++]) == 'u'
2339: && Character.toLowerCase(buffer[offset++]) == 'r' && Character
2340: .toLowerCase(buffer[offset++]) == 'e') ? FTokenContext.KW_STRUCTURE
2341: : null;
2342:
2343: default:
2344: return null;
2345: }//switch st
2346:
2347: case 'u': // subroutine
2348: return (len == 10
2349: && Character.toLowerCase(buffer[offset++]) == 'b'
2350: && Character.toLowerCase(buffer[offset++]) == 'r'
2351: && Character.toLowerCase(buffer[offset++]) == 'o'
2352: && Character.toLowerCase(buffer[offset++]) == 'u'
2353: && Character.toLowerCase(buffer[offset++]) == 't'
2354: && Character.toLowerCase(buffer[offset++]) == 'i'
2355: && Character.toLowerCase(buffer[offset++]) == 'n' && Character
2356: .toLowerCase(buffer[offset++]) == 'e') ? FTokenContext.KW_SUBROUTINE
2357: : null;
2358:
2359: default:
2360: return null;
2361: }//switch s
2362: //END S
2363:
2364: //T
2365: //target then to type
2366: case 't': // then type
2367: if ((len < 2) || (len > 6))
2368: return null;
2369:
2370: switch (Character.toLowerCase(buffer[offset++])) {
2371: case 'a': // target
2372: return (len == 6
2373: && Character.toLowerCase(buffer[offset++]) == 'r'
2374: && Character.toLowerCase(buffer[offset++]) == 'g'
2375: && Character.toLowerCase(buffer[offset++]) == 'e' && Character
2376: .toLowerCase(buffer[offset++]) == 't') ? FTokenContext.KW_TARGET
2377: : null;
2378:
2379: case 'h': // then
2380: return (len == 4
2381: && Character.toLowerCase(buffer[offset++]) == 'e' && Character
2382: .toLowerCase(buffer[offset++]) == 'n') ? FTokenContext.KW_THEN
2383: : null;
2384:
2385: case 'o': // to
2386: return (len == 2) ? FTokenContext.KW_TO : null;
2387:
2388: case 'y': // type
2389: return (len == 4
2390: && Character.toLowerCase(buffer[offset++]) == 'p' && Character
2391: .toLowerCase(buffer[offset++]) == 'e') ? FTokenContext.KW_TYPE
2392: : null;
2393:
2394: default:
2395: return null;
2396: } //switch t
2397: //END T
2398:
2399: //U
2400: //unformatted= use
2401: case 'u':
2402: if ((len < 3) || (len > 12))
2403: return null;
2404:
2405: switch (Character.toLowerCase(buffer[offset++])) {
2406: case 'n':
2407: switch (Character.toLowerCase(buffer[offset++])) {
2408: case 'f': //unformatted=
2409: return (len == 12
2410: && Character.toLowerCase(buffer[offset++]) == 'o'
2411: && Character.toLowerCase(buffer[offset++]) == 'r'
2412: && Character.toLowerCase(buffer[offset++]) == 'm'
2413: && Character.toLowerCase(buffer[offset++]) == 'a'
2414: && Character.toLowerCase(buffer[offset++]) == 't'
2415: && Character.toLowerCase(buffer[offset++]) == 't'
2416: && Character.toLowerCase(buffer[offset++]) == 'e'
2417: && Character.toLowerCase(buffer[offset++]) == 'd' && Character
2418: .toLowerCase(buffer[offset++]) == '=') ? FTokenContext.KW_UNFORMATTED_EQ
2419: : null;
2420: case 'i': //union
2421: return (len == 5
2422: && Character.toLowerCase(buffer[offset++]) == 'o' && Character
2423: .toLowerCase(buffer[offset++]) == 'n') ? FTokenContext.KW_UNION
2424: : null;
2425: default:
2426: return null;
2427: }//end switch
2428: case 's': //use
2429: return (len == 3 && Character
2430: .toLowerCase(buffer[offset++]) == 'e') ? FTokenContext.KW_USE
2431: : null;
2432:
2433: default:
2434: return null;
2435: }//switch un
2436: //END U
2437:
2438: //W
2439: //where while write write=
2440: case 'w': // where while write
2441: if ((len < 5) || (len > 6))
2442: return null;
2443:
2444: switch (Character.toLowerCase(buffer[offset++])) {
2445: case 'h': // where while
2446: switch (Character.toLowerCase(buffer[offset++])) {
2447: case 'e': // where
2448: return (len == 5
2449: && Character.toLowerCase(buffer[offset++]) == 'r' && Character
2450: .toLowerCase(buffer[offset++]) == 'e') ? FTokenContext.KW_WHERE
2451: : null;
2452: case 'i': // while
2453: return (len == 5
2454: && Character.toLowerCase(buffer[offset++]) == 'l' && Character
2455: .toLowerCase(buffer[offset++]) == 'e') ? FTokenContext.KW_WHILE
2456: : null;
2457: default:
2458: return null;
2459: }//switch wh
2460:
2461: case 'r': // write write=
2462: if (len >= 5
2463: && Character.toLowerCase(buffer[offset++]) == 'i'
2464: && Character.toLowerCase(buffer[offset++]) == 't'
2465: && Character.toLowerCase(buffer[offset++]) == 'e') {
2466: if (len == 5)
2467: return FTokenContext.KW_WRITE;
2468: else if (len == 6
2469: && Character.toLowerCase(buffer[offset++]) == '=')
2470: return FTokenContext.KW_WRITE_EQ;
2471: else
2472: return null;
2473: } else
2474: return null;
2475:
2476: default:
2477: return null;
2478: }//switch w
2479: //END W
2480:
2481: default:
2482: return null;
2483: } //switch
2484: //END MOTHER SWITCH
2485: } //matchKeyword
2486:
2487: public static class MyStateInfo extends Syntax.BaseStateInfo {
2488:
2489: /** the column number of last porcessed character */
2490: private int column;
2491:
2492: public int getColumn() {
2493: return column;
2494: }
2495:
2496: public void setColumn(int column) {
2497: this .column = column;
2498: }
2499: }
2500:
2501: /** Load valid mark state into the analyzer. Offsets
2502: * are already initialized when this method is called. This method
2503: * must get the state from the mark and set it to the analyzer. Then
2504: * it must decrease tokenOffset by the preScan stored in the mark state.
2505: * @param markState mark state to be loaded into syntax. It must be non-null value.
2506: */
2507: public void loadState(StateInfo stateInfo) {
2508: super .loadState(stateInfo);
2509: // lastNL < 0 means that the last \n was somewhere in the previous buffer.
2510: lastNL = offset - ((MyStateInfo) stateInfo).getColumn();
2511: }
2512:
2513: /** Store state of this analyzer into given mark state. */
2514: public void storeState(StateInfo stateInfo) {
2515: super .storeState(stateInfo);
2516: ((MyStateInfo) stateInfo).setColumn(offset - lastNL);
2517: }
2518:
2519: /** Compare state of this analyzer to given state info */
2520: public int compareState(StateInfo stateInfo) {
2521: if (super .compareState(stateInfo) == DIFFERENT_STATE)
2522: return DIFFERENT_STATE;
2523: return (((MyStateInfo) stateInfo).getColumn() == (offset - lastNL)) ? EQUAL_STATE
2524: : DIFFERENT_STATE;
2525: }
2526:
2527: /** Create state info appropriate for particular analyzer */
2528: public StateInfo createStateInfo() {
2529: return new MyStateInfo();
2530: }
2531:
2532: }
|