# Generated from Fortran77Parser.g4 by ANTLR 4.8
# encoding: utf-8
from antlr4 import *
from io import StringIO
import sys
if sys.version_info[1] > 5:
from typing import TextIO
else:
from typing.io import TextIO
[docs]
def serializedATN():
with StringIO() as buf:
buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3{")
buf.write("\u06d8\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t")
buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4")
buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64")
buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t")
buf.write(";\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\t")
buf.write("D\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\t")
buf.write("M\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT\4U\tU\4V\t")
buf.write("V\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4")
buf.write("_\t_\4`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4")
buf.write("h\th\4i\ti\4j\tj\4k\tk\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4")
buf.write("q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4w\tw\4x\tx\4y\ty\4")
buf.write("z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080")
buf.write("\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084")
buf.write("\t\u0084\4\u0085\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087")
buf.write("\4\u0088\t\u0088\4\u0089\t\u0089\4\u008a\t\u008a\4\u008b")
buf.write("\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e\t\u008e")
buf.write("\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092")
buf.write("\t\u0092\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095\t\u0095")
buf.write("\4\u0096\t\u0096\4\u0097\t\u0097\4\u0098\t\u0098\4\u0099")
buf.write("\t\u0099\4\u009a\t\u009a\4\u009b\t\u009b\4\u009c\t\u009c")
buf.write("\4\u009d\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f\4\u00a0")
buf.write("\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3\t\u00a3")
buf.write("\4\u00a4\t\u00a4\4\u00a5\t\u00a5\4\u00a6\t\u00a6\4\u00a7")
buf.write("\t\u00a7\4\u00a8\t\u00a8\4\u00a9\t\u00a9\4\u00aa\t\u00aa")
buf.write("\4\u00ab\t\u00ab\4\u00ac\t\u00ac\4\u00ad\t\u00ad\4\u00ae")
buf.write("\t\u00ae\4\u00af\t\u00af\4\u00b0\t\u00b0\4\u00b1\t\u00b1")
buf.write("\4\u00b2\t\u00b2\4\u00b3\t\u00b3\4\u00b4\t\u00b4\4\u00b5")
buf.write("\t\u00b5\4\u00b6\t\u00b6\4\u00b7\t\u00b7\4\u00b8\t\u00b8")
buf.write("\4\u00b9\t\u00b9\4\u00ba\t\u00ba\4\u00bb\t\u00bb\4\u00bc")
buf.write("\t\u00bc\4\u00bd\t\u00bd\4\u00be\t\u00be\4\u00bf\t\u00bf")
buf.write("\4\u00c0\t\u00c0\4\u00c1\t\u00c1\4\u00c2\t\u00c2\4\u00c3")
buf.write("\t\u00c3\3\2\6\2\u0188\n\2\r\2\16\2\u0189\3\3\7\3\u018d")
buf.write("\n\3\f\3\16\3\u0190\13\3\3\3\3\3\7\3\u0194\n\3\f\3\16")
buf.write("\3\u0197\13\3\6\3\u0199\n\3\r\3\16\3\u019a\3\3\7\3\u019e")
buf.write("\n\3\f\3\16\3\u01a1\13\3\3\4\3\4\3\4\3\4\5\4\u01a7\n\4")
buf.write("\3\5\5\5\u01aa\n\5\3\5\3\5\3\6\3\6\3\6\3\7\3\7\3\7\3\b")
buf.write("\3\b\3\b\3\t\3\t\3\t\3\t\5\t\u01bb\n\t\3\n\3\n\3\n\3\n")
buf.write("\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3")
buf.write("\n\5\n\u01cf\n\n\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\f\3")
buf.write("\f\3\f\5\f\u01db\n\f\3\r\5\r\u01de\n\r\3\r\3\r\3\r\3\r")
buf.write("\5\r\u01e4\n\r\3\r\3\r\5\r\u01e8\n\r\3\16\3\16\3\16\3")
buf.write("\17\3\17\3\17\3\17\5\17\u01f1\n\17\3\17\5\17\u01f4\n\17")
buf.write("\3\17\5\17\u01f7\n\17\3\20\3\20\3\20\7\20\u01fc\n\20\f")
buf.write("\20\16\20\u01ff\13\20\3\21\3\21\3\21\3\21\3\21\3\21\3")
buf.write("\21\3\21\3\21\3\21\3\21\3\21\3\21\5\21\u020e\n\21\3\22")
buf.write("\7\22\u0211\n\22\f\22\16\22\u0214\13\22\3\22\3\22\7\22")
buf.write("\u0218\n\22\f\22\16\22\u021b\13\22\6\22\u021d\n\22\r\22")
buf.write("\16\22\u021e\3\22\3\22\3\23\5\23\u0224\n\23\3\23\3\23")
buf.write("\3\23\3\24\5\24\u022a\n\24\3\24\3\24\3\25\3\25\3\25\3")
buf.write("\26\3\26\3\26\3\26\3\26\3\27\3\27\3\27\7\27\u0239\n\27")
buf.write("\f\27\16\27\u023c\13\27\3\30\3\30\3\30\7\30\u0241\n\30")
buf.write("\f\30\16\30\u0244\13\30\3\31\3\31\3\31\3\31\5\31\u024a")
buf.write("\n\31\5\31\u024c\n\31\3\31\5\31\u024f\n\31\3\32\3\32\3")
buf.write("\32\3\32\7\32\u0255\n\32\f\32\16\32\u0258\13\32\3\33\3")
buf.write("\33\3\33\3\33\7\33\u025e\n\33\f\33\16\33\u0261\13\33\3")
buf.write("\33\3\33\3\34\3\34\3\35\3\35\3\35\3\35\7\35\u026b\n\35")
buf.write("\f\35\16\35\u026e\13\35\3\35\5\35\u0271\n\35\3\36\3\36")
buf.write("\3\36\3\36\5\36\u0277\n\36\3\37\3\37\5\37\u027b\n\37\3")
buf.write(" \3 \3 \7 \u0280\n \f \16 \u0283\13 \3!\3!\3!\3\"\3\"")
buf.write("\3\"\3\"\3\"\3\"\5\"\u028e\n\"\3#\3#\3#\7#\u0293\n#\f")
buf.write("#\16#\u0296\13#\3$\3$\5$\u029a\n$\3%\3%\3%\7%\u029f\n")
buf.write("%\f%\16%\u02a2\13%\3&\3&\5&\u02a6\n&\3\'\3\'\3\'\3(\3")
buf.write("(\3(\3(\5(\u02af\n(\5(\u02b1\n(\3(\3(\3(\3(\3(\3(\3(\5")
buf.write("(\u02ba\n(\3)\3)\5)\u02be\n)\3*\3*\3*\3+\3+\3+\3+\7+\u02c7")
buf.write("\n+\f+\16+\u02ca\13+\3,\3,\3,\3,\3,\3,\3-\3-\3-\5-\u02d5")
buf.write("\n-\3.\3.\3.\3.\3.\3/\3/\3/\7/\u02df\n/\f/\16/\u02e2\13")
buf.write("/\3\60\3\60\3\61\3\61\3\62\3\62\3\62\5\62\u02eb\n\62\3")
buf.write("\63\3\63\3\63\7\63\u02f0\n\63\f\63\16\63\u02f3\13\63\3")
buf.write("\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64")
buf.write("\3\64\5\64\u0301\n\64\3\65\3\65\5\65\u0305\n\65\3\66\3")
buf.write("\66\3\66\3\67\3\67\3\67\3\67\3\67\38\38\38\78\u0312\n")
buf.write("8\f8\168\u0315\138\39\39\39\39\3:\3:\3:\3;\3;\3;\3<\3")
buf.write("<\3<\3<\7<\u0325\n<\f<\16<\u0328\13<\5<\u032a\n<\3=\3")
buf.write("=\3=\3=\5=\u0330\n=\3>\3>\3>\5>\u0335\n>\3>\7>\u0338\n")
buf.write(">\f>\16>\u033b\13>\3?\3?\5?\u033f\n?\3@\3@\5@\u0343\n")
buf.write("@\3@\3@\5@\u0347\n@\3A\3A\3A\3B\3B\3B\7B\u034f\nB\fB\16")
buf.write("B\u0352\13B\3B\3B\3C\3C\3C\7C\u0359\nC\fC\16C\u035c\13")
buf.write("C\3C\3C\3D\3D\3D\3D\3D\3D\3E\3E\3E\3E\3E\3E\3E\5E\u036d")
buf.write("\nE\3F\3F\3F\5F\u0372\nF\3G\3G\5G\u0376\nG\3H\3H\3H\3")
buf.write("H\3H\3H\5H\u037e\nH\3I\3I\3J\3J\3J\3J\5J\u0386\nJ\3J\3")
buf.write("J\3K\3K\3L\3L\3L\7L\u038f\nL\fL\16L\u0392\13L\3M\3M\5")
buf.write("M\u0396\nM\3M\3M\3M\3M\5M\u039c\nM\3N\3N\3N\3N\3N\3N\3")
buf.write("N\5N\u03a5\nN\3O\3O\3O\3O\3O\3O\3P\3P\3Q\3Q\7Q\u03b1\n")
buf.write("Q\fQ\16Q\u03b4\13Q\3Q\5Q\u03b7\nQ\3Q\3Q\3R\3R\5R\u03bd")
buf.write("\nR\3R\7R\u03c0\nR\fR\16R\u03c3\13R\3R\3R\7R\u03c7\nR")
buf.write("\fR\16R\u03ca\13R\6R\u03cc\nR\rR\16R\u03cd\3S\3S\3S\5")
buf.write("S\u03d3\nS\3S\3S\3S\3S\3S\5S\u03da\nS\3S\6S\u03dd\nS\r")
buf.write("S\16S\u03de\3T\3T\5T\u03e3\nT\3T\7T\u03e6\nT\fT\16T\u03e9")
buf.write("\13T\3T\3T\7T\u03ed\nT\fT\16T\u03f0\13T\6T\u03f2\nT\r")
buf.write("T\16T\u03f3\3U\3U\3U\5U\u03f9\nU\3V\3V\3V\5V\u03fe\nV")
buf.write("\3W\3W\3W\3W\3W\3W\3W\5W\u0407\nW\3X\3X\5X\u040b\nX\3")
buf.write("X\3X\5X\u040f\nX\3X\3X\5X\u0413\nX\3X\3X\3Y\6Y\u0418\n")
buf.write("Y\rY\16Y\u0419\3Z\3Z\5Z\u041e\nZ\3Z\3Z\5Z\u0422\nZ\3Z")
buf.write("\3Z\3[\3[\3[\5[\u0429\n[\3\\\7\\\u042c\n\\\f\\\16\\\u042f")
buf.write("\13\\\3\\\3\\\3]\3]\5]\u0435\n]\3^\3^\3^\3_\3_\3_\3_\3")
buf.write("_\5_\u043f\n_\3_\6_\u0442\n_\r_\16_\u0443\5_\u0446\n_")
buf.write("\3`\3`\3`\3`\6`\u044c\n`\r`\16`\u044d\5`\u0450\n`\3a\3")
buf.write("a\3a\3a\6a\u0456\na\ra\16a\u0457\5a\u045a\na\3b\3b\3b")
buf.write("\3b\3c\3c\3c\7c\u0463\nc\fc\16c\u0466\13c\3d\3d\3d\3d")
buf.write("\5d\u046c\nd\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3")
buf.write("e\3e\3e\3e\3e\3e\3e\3e\3e\3e\5e\u0485\ne\3f\3f\3f\3f\3")
buf.write("f\3f\3f\3f\3f\3f\3f\3f\3f\3f\3f\3f\5f\u0497\nf\3g\3g\3")
buf.write("g\3g\3g\3g\3g\3g\3g\5g\u04a2\ng\3h\3h\3h\3h\3h\3h\3h\3")
buf.write("h\3h\3h\5h\u04ae\nh\3h\3h\3i\3i\3i\3i\3i\7i\u04b7\ni\f")
buf.write("i\16i\u04ba\13i\3i\3i\3j\3j\3j\3j\3j\3j\3j\3j\3j\3j\3")
buf.write("j\3j\3j\3j\3j\3j\5j\u04ce\nj\3j\3j\3j\3j\3j\3j\3j\3j\3")
buf.write("j\3j\3j\3j\3j\3j\3j\3j\3j\3j\3j\5j\u04e3\nj\3k\3k\3l\3")
buf.write("l\3m\3m\3n\3n\3o\3o\3p\3p\3q\3q\3r\3r\3s\3s\3t\3t\3u\3")
buf.write("u\3v\3v\3w\3w\3x\3x\3y\3y\3z\3z\3{\3{\3|\3|\3}\3}\3~\3")
buf.write("~\3\177\3\177\3\u0080\3\u0080\3\u0081\3\u0081\3\u0082")
buf.write("\3\u0082\3\u0082\3\u0082\3\u0082\7\u0082\u0518\n\u0082")
buf.write("\f\u0082\16\u0082\u051b\13\u0082\3\u0082\3\u0082\3\u0083")
buf.write("\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083")
buf.write("\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083\5\u0083")
buf.write("\u052d\n\u0083\3\u0084\3\u0084\3\u0084\3\u0084\3\u0084")
buf.write("\7\u0084\u0534\n\u0084\f\u0084\16\u0084\u0537\13\u0084")
buf.write("\3\u0084\3\u0084\3\u0085\3\u0085\3\u0085\3\u0085\3\u0085")
buf.write("\3\u0085\3\u0085\3\u0085\3\u0085\3\u0085\3\u0085\3\u0085")
buf.write("\3\u0085\3\u0085\3\u0085\3\u0085\3\u0085\3\u0085\3\u0085")
buf.write("\3\u0085\3\u0085\3\u0085\3\u0085\3\u0085\5\u0085\u0553")
buf.write("\n\u0085\3\u0085\3\u0085\3\u0085\3\u0085\5\u0085\u0559")
buf.write("\n\u0085\3\u0086\3\u0086\3\u0086\3\u0087\3\u0087\3\u0087")
buf.write("\3\u0088\3\u0088\3\u0088\3\u0089\3\u0089\3\u0089\3\u0089")
buf.write("\3\u0089\3\u0089\3\u0089\7\u0089\u056b\n\u0089\f\u0089")
buf.write("\16\u0089\u056e\13\u0089\3\u0089\3\u0089\5\u0089\u0572")
buf.write("\n\u0089\3\u008a\3\u008a\3\u008a\3\u008a\3\u008a\3\u008a")
buf.write("\3\u008a\3\u008a\3\u008a\3\u008a\5\u008a\u057e\n\u008a")
buf.write("\3\u008b\3\u008b\5\u008b\u0582\n\u008b\3\u008c\3\u008c")
buf.write("\3\u008c\5\u008c\u0587\n\u008c\3\u008d\3\u008d\3\u008d")
buf.write("\3\u008d\3\u008d\3\u008e\3\u008e\3\u008e\5\u008e\u0591")
buf.write("\n\u008e\5\u008e\u0593\n\u008e\3\u008e\3\u008e\5\u008e")
buf.write("\u0597\n\u008e\3\u008e\3\u008e\3\u008e\3\u008e\5\u008e")
buf.write("\u059d\n\u008e\5\u008e\u059f\n\u008e\7\u008e\u05a1\n\u008e")
buf.write("\f\u008e\16\u008e\u05a4\13\u008e\3\u008f\3\u008f\3\u0090")
buf.write("\3\u0090\3\u0090\3\u0090\3\u0090\5\u0090\u05ad\n\u0090")
buf.write("\3\u0090\3\u0090\5\u0090\u05b1\n\u0090\3\u0090\5\u0090")
buf.write("\u05b4\n\u0090\5\u0090\u05b6\n\u0090\3\u0091\3\u0091\3")
buf.write("\u0091\3\u0091\3\u0091\5\u0091\u05bd\n\u0091\3\u0092\3")
buf.write("\u0092\3\u0092\3\u0092\3\u0092\3\u0093\3\u0093\3\u0093")
buf.write("\3\u0093\3\u0093\3\u0094\3\u0094\3\u0094\3\u0095\3\u0095")
buf.write("\3\u0095\5\u0095\u05cf\n\u0095\3\u0095\5\u0095\u05d2\n")
buf.write("\u0095\3\u0096\3\u0096\3\u0096\7\u0096\u05d7\n\u0096\f")
buf.write("\u0096\16\u0096\u05da\13\u0096\3\u0097\3\u0097\3\u0097")
buf.write("\5\u0097\u05df\n\u0097\3\u0098\3\u0098\5\u0098\u05e3\n")
buf.write("\u0098\3\u0099\3\u0099\3\u0099\5\u0099\u05e8\n\u0099\3")
buf.write("\u009a\3\u009a\3\u009a\3\u009a\7\u009a\u05ee\n\u009a\f")
buf.write("\u009a\16\u009a\u05f1\13\u009a\3\u009b\3\u009b\3\u009b")
buf.write("\7\u009b\u05f6\n\u009b\f\u009b\16\u009b\u05f9\13\u009b")
buf.write("\3\u009c\3\u009c\3\u009c\7\u009c\u05fe\n\u009c\f\u009c")
buf.write("\16\u009c\u0601\13\u009c\3\u009d\3\u009d\3\u009d\7\u009d")
buf.write("\u0606\n\u009d\f\u009d\16\u009d\u0609\13\u009d\3\u009e")
buf.write("\3\u009e\3\u009e\5\u009e\u060e\n\u009e\3\u009f\3\u009f")
buf.write("\3\u009f\5\u009f\u0613\n\u009f\3\u00a0\3\u00a0\3\u00a0")
buf.write("\7\u00a0\u0618\n\u00a0\f\u00a0\16\u00a0\u061b\13\u00a0")
buf.write("\3\u00a1\3\u00a1\3\u00a1\7\u00a1\u0620\n\u00a1\f\u00a1")
buf.write("\16\u00a1\u0623\13\u00a1\3\u00a2\7\u00a2\u0626\n\u00a2")
buf.write("\f\u00a2\16\u00a2\u0629\13\u00a2\3\u00a2\3\u00a2\3\u00a3")
buf.write("\3\u00a3\3\u00a3\7\u00a3\u0630\n\u00a3\f\u00a3\16\u00a3")
buf.write("\u0633\13\u00a3\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4")
buf.write("\3\u00a4\3\u00a4\3\u00a4\5\u00a4\u063d\n\u00a4\3\u00a5")
buf.write("\3\u00a5\3\u00a5\7\u00a5\u0642\n\u00a5\f\u00a5\16\u00a5")
buf.write("\u0645\13\u00a5\3\u00a6\3\u00a6\3\u00a6\7\u00a6\u064a")
buf.write("\n\u00a6\f\u00a6\16\u00a6\u064d\13\u00a6\3\u00a7\3\u00a7")
buf.write("\3\u00a7\7\u00a7\u0652\n\u00a7\f\u00a7\16\u00a7\u0655")
buf.write("\13\u00a7\3\u00a8\7\u00a8\u0658\n\u00a8\f\u00a8\16\u00a8")
buf.write("\u065b\13\u00a8\3\u00a8\3\u00a8\3\u00a9\3\u00a9\3\u00a9")
buf.write("\5\u00a9\u0662\n\u00a9\3\u00aa\3\u00aa\3\u00aa\3\u00aa")
buf.write("\3\u00aa\3\u00aa\5\u00aa\u066a\n\u00aa\3\u00ab\3\u00ab")
buf.write("\3\u00ac\3\u00ac\3\u00ad\3\u00ad\3\u00ae\3\u00ae\3\u00af")
buf.write("\3\u00af\3\u00b0\3\u00b0\3\u00b1\3\u00b1\3\u00b2\3\u00b2")
buf.write("\3\u00b2\3\u00b3\3\u00b3\3\u00b4\3\u00b4\3\u00b5\3\u00b5")
buf.write("\3\u00b5\3\u00b5\3\u00b5\7\u00b5\u0686\n\u00b5\f\u00b5")
buf.write("\16\u00b5\u0689\13\u00b5\3\u00b5\3\u00b5\3\u00b6\3\u00b6")
buf.write("\3\u00b6\3\u00b6\7\u00b6\u0691\n\u00b6\f\u00b6\16\u00b6")
buf.write("\u0694\13\u00b6\5\u00b6\u0696\n\u00b6\3\u00b6\3\u00b6")
buf.write("\3\u00b7\3\u00b7\3\u00b7\5\u00b7\u069d\n\u00b7\5\u00b7")
buf.write("\u069f\n\u00b7\3\u00b8\3\u00b8\3\u00b8\5\u00b8\u06a4\n")
buf.write("\u00b8\5\u00b8\u06a6\n\u00b8\3\u00b9\3\u00b9\5\u00b9\u06aa")
buf.write("\n\u00b9\3\u00b9\3\u00b9\5\u00b9\u06ae\n\u00b9\3\u00b9")
buf.write("\3\u00b9\3\u00ba\3\u00ba\3\u00bb\3\u00bb\3\u00bc\3\u00bc")
buf.write("\3\u00bd\3\u00bd\3\u00be\5\u00be\u06bb\n\u00be\3\u00be")
buf.write("\3\u00be\3\u00be\5\u00be\u06c0\n\u00be\3\u00bf\3\u00bf")
buf.write("\5\u00bf\u06c4\n\u00bf\3\u00c0\3\u00c0\5\u00c0\u06c8\n")
buf.write("\u00c0\3\u00c0\3\u00c0\3\u00c0\5\u00c0\u06cd\n\u00c0\3")
buf.write("\u00c0\3\u00c0\3\u00c0\3\u00c1\3\u00c1\3\u00c2\3\u00c2")
buf.write("\3\u00c3\3\u00c3\3\u00c3\2\2\u00c4\2\4\6\b\n\f\16\20\22")
buf.write("\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPR")
buf.write("TVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088")
buf.write("\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098\u009a")
buf.write("\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac")
buf.write("\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc\u00be")
buf.write("\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce\u00d0")
buf.write("\u00d2\u00d4\u00d6\u00d8\u00da\u00dc\u00de\u00e0\u00e2")
buf.write("\u00e4\u00e6\u00e8\u00ea\u00ec\u00ee\u00f0\u00f2\u00f4")
buf.write("\u00f6\u00f8\u00fa\u00fc\u00fe\u0100\u0102\u0104\u0106")
buf.write("\u0108\u010a\u010c\u010e\u0110\u0112\u0114\u0116\u0118")
buf.write("\u011a\u011c\u011e\u0120\u0122\u0124\u0126\u0128\u012a")
buf.write("\u012c\u012e\u0130\u0132\u0134\u0136\u0138\u013a\u013c")
buf.write("\u013e\u0140\u0142\u0144\u0146\u0148\u014a\u014c\u014e")
buf.write("\u0150\u0152\u0154\u0156\u0158\u015a\u015c\u015e\u0160")
buf.write("\u0162\u0164\u0166\u0168\u016a\u016c\u016e\u0170\u0172")
buf.write("\u0174\u0176\u0178\u017a\u017c\u017e\u0180\u0182\u0184")
buf.write("\2\17\4\2\n\nuu\3\2tu\3\2\26\27\4\2cctt\4\2ccrr\5\2FF")
buf.write("JJNN\3\2LM\6\2aaccrruu\3\2ST\3\2W\\\4\2NNww\3\2st\3\2")
buf.write("]^\2\u0711\2\u0187\3\2\2\2\4\u018e\3\2\2\2\6\u01a6\3\2")
buf.write("\2\2\b\u01a9\3\2\2\2\n\u01ad\3\2\2\2\f\u01b0\3\2\2\2\16")
buf.write("\u01b3\3\2\2\2\20\u01ba\3\2\2\2\22\u01ce\3\2\2\2\24\u01d0")
buf.write("\3\2\2\2\26\u01d4\3\2\2\2\30\u01dd\3\2\2\2\32\u01e9\3")
buf.write("\2\2\2\34\u01ec\3\2\2\2\36\u01f8\3\2\2\2 \u020d\3\2\2")
buf.write("\2\"\u0212\3\2\2\2$\u0223\3\2\2\2&\u0229\3\2\2\2(\u022d")
buf.write("\3\2\2\2*\u0230\3\2\2\2,\u0235\3\2\2\2.\u023d\3\2\2\2")
buf.write("\60\u024e\3\2\2\2\62\u0250\3\2\2\2\64\u0259\3\2\2\2\66")
buf.write("\u0264\3\2\2\28\u0266\3\2\2\2:\u0272\3\2\2\2<\u027a\3")
buf.write("\2\2\2>\u027c\3\2\2\2@\u0284\3\2\2\2B\u028d\3\2\2\2D\u028f")
buf.write("\3\2\2\2F\u0299\3\2\2\2H\u029b\3\2\2\2J\u02a3\3\2\2\2")
buf.write("L\u02a7\3\2\2\2N\u02b9\3\2\2\2P\u02bd\3\2\2\2R\u02bf\3")
buf.write("\2\2\2T\u02c2\3\2\2\2V\u02cb\3\2\2\2X\u02d1\3\2\2\2Z\u02d6")
buf.write("\3\2\2\2\\\u02db\3\2\2\2^\u02e3\3\2\2\2`\u02e5\3\2\2\2")
buf.write("b\u02e7\3\2\2\2d\u02ec\3\2\2\2f\u0300\3\2\2\2h\u0302\3")
buf.write("\2\2\2j\u0306\3\2\2\2l\u0309\3\2\2\2n\u030e\3\2\2\2p\u0316")
buf.write("\3\2\2\2r\u031a\3\2\2\2t\u031d\3\2\2\2v\u0320\3\2\2\2")
buf.write("x\u032f\3\2\2\2z\u0331\3\2\2\2|\u033e\3\2\2\2~\u0342\3")
buf.write("\2\2\2\u0080\u0348\3\2\2\2\u0082\u034b\3\2\2\2\u0084\u0355")
buf.write("\3\2\2\2\u0086\u035f\3\2\2\2\u0088\u0365\3\2\2\2\u008a")
buf.write("\u0371\3\2\2\2\u008c\u0375\3\2\2\2\u008e\u0377\3\2\2\2")
buf.write("\u0090\u037f\3\2\2\2\u0092\u0381\3\2\2\2\u0094\u0389\3")
buf.write("\2\2\2\u0096\u038b\3\2\2\2\u0098\u0393\3\2\2\2\u009a\u039d")
buf.write("\3\2\2\2\u009c\u03a6\3\2\2\2\u009e\u03ac\3\2\2\2\u00a0")
buf.write("\u03ae\3\2\2\2\u00a2\u03ba\3\2\2\2\u00a4\u03d2\3\2\2\2")
buf.write("\u00a6\u03e0\3\2\2\2\u00a8\u03f8\3\2\2\2\u00aa\u03fa\3")
buf.write("\2\2\2\u00ac\u03ff\3\2\2\2\u00ae\u0408\3\2\2\2\u00b0\u0417")
buf.write("\3\2\2\2\u00b2\u041b\3\2\2\2\u00b4\u0428\3\2\2\2\u00b6")
buf.write("\u042d\3\2\2\2\u00b8\u0432\3\2\2\2\u00ba\u0436\3\2\2\2")
buf.write("\u00bc\u0439\3\2\2\2\u00be\u0447\3\2\2\2\u00c0\u0451\3")
buf.write("\2\2\2\u00c2\u045b\3\2\2\2\u00c4\u045f\3\2\2\2\u00c6\u0467")
buf.write("\3\2\2\2\u00c8\u0484\3\2\2\2\u00ca\u0496\3\2\2\2\u00cc")
buf.write("\u04a1\3\2\2\2\u00ce\u04a3\3\2\2\2\u00d0\u04b1\3\2\2\2")
buf.write("\u00d2\u04e2\3\2\2\2\u00d4\u04e4\3\2\2\2\u00d6\u04e6\3")
buf.write("\2\2\2\u00d8\u04e8\3\2\2\2\u00da\u04ea\3\2\2\2\u00dc\u04ec")
buf.write("\3\2\2\2\u00de\u04ee\3\2\2\2\u00e0\u04f0\3\2\2\2\u00e2")
buf.write("\u04f2\3\2\2\2\u00e4\u04f4\3\2\2\2\u00e6\u04f6\3\2\2\2")
buf.write("\u00e8\u04f8\3\2\2\2\u00ea\u04fa\3\2\2\2\u00ec\u04fc\3")
buf.write("\2\2\2\u00ee\u04fe\3\2\2\2\u00f0\u0500\3\2\2\2\u00f2\u0502")
buf.write("\3\2\2\2\u00f4\u0504\3\2\2\2\u00f6\u0506\3\2\2\2\u00f8")
buf.write("\u0508\3\2\2\2\u00fa\u050a\3\2\2\2\u00fc\u050c\3\2\2\2")
buf.write("\u00fe\u050e\3\2\2\2\u0100\u0510\3\2\2\2\u0102\u0512\3")
buf.write("\2\2\2\u0104\u052c\3\2\2\2\u0106\u052e\3\2\2\2\u0108\u0558")
buf.write("\3\2\2\2\u010a\u055a\3\2\2\2\u010c\u055d\3\2\2\2\u010e")
buf.write("\u0560\3\2\2\2\u0110\u0571\3\2\2\2\u0112\u057d\3\2\2\2")
buf.write("\u0114\u0581\3\2\2\2\u0116\u0586\3\2\2\2\u0118\u0588\3")
buf.write("\2\2\2\u011a\u0592\3\2\2\2\u011c\u05a5\3\2\2\2\u011e\u05b5")
buf.write("\3\2\2\2\u0120\u05bc\3\2\2\2\u0122\u05be\3\2\2\2\u0124")
buf.write("\u05c3\3\2\2\2\u0126\u05c8\3\2\2\2\u0128\u05cb\3\2\2\2")
buf.write("\u012a\u05d3\3\2\2\2\u012c\u05de\3\2\2\2\u012e\u05e0\3")
buf.write("\2\2\2\u0130\u05e4\3\2\2\2\u0132\u05e9\3\2\2\2\u0134\u05f2")
buf.write("\3\2\2\2\u0136\u05fa\3\2\2\2\u0138\u0602\3\2\2\2\u013a")
buf.write("\u060d\3\2\2\2\u013c\u060f\3\2\2\2\u013e\u0614\3\2\2\2")
buf.write("\u0140\u061c\3\2\2\2\u0142\u0627\3\2\2\2\u0144\u062c\3")
buf.write("\2\2\2\u0146\u063c\3\2\2\2\u0148\u063e\3\2\2\2\u014a\u0646")
buf.write("\3\2\2\2\u014c\u064e\3\2\2\2\u014e\u0659\3\2\2\2\u0150")
buf.write("\u065e\3\2\2\2\u0152\u0669\3\2\2\2\u0154\u066b\3\2\2\2")
buf.write("\u0156\u066d\3\2\2\2\u0158\u066f\3\2\2\2\u015a\u0671\3")
buf.write("\2\2\2\u015c\u0673\3\2\2\2\u015e\u0675\3\2\2\2\u0160\u0677")
buf.write("\3\2\2\2\u0162\u0679\3\2\2\2\u0164\u067c\3\2\2\2\u0166")
buf.write("\u067e\3\2\2\2\u0168\u0680\3\2\2\2\u016a\u068c\3\2\2\2")
buf.write("\u016c\u0699\3\2\2\2\u016e\u06a0\3\2\2\2\u0170\u06a7\3")
buf.write("\2\2\2\u0172\u06b1\3\2\2\2\u0174\u06b3\3\2\2\2\u0176\u06b5")
buf.write("\3\2\2\2\u0178\u06b7\3\2\2\2\u017a\u06bf\3\2\2\2\u017c")
buf.write("\u06c3\3\2\2\2\u017e\u06c5\3\2\2\2\u0180\u06d1\3\2\2\2")
buf.write("\u0182\u06d3\3\2\2\2\u0184\u06d5\3\2\2\2\u0186\u0188\7")
buf.write("v\2\2\u0187\u0186\3\2\2\2\u0188\u0189\3\2\2\2\u0189\u0187")
buf.write("\3\2\2\2\u0189\u018a\3\2\2\2\u018a\3\3\2\2\2\u018b\u018d")
buf.write("\5\2\2\2\u018c\u018b\3\2\2\2\u018d\u0190\3\2\2\2\u018e")
buf.write("\u018c\3\2\2\2\u018e\u018f\3\2\2\2\u018f\u0198\3\2\2\2")
buf.write("\u0190\u018e\3\2\2\2\u0191\u0195\5\6\4\2\u0192\u0194\5")
buf.write("\2\2\2\u0193\u0192\3\2\2\2\u0194\u0197\3\2\2\2\u0195\u0193")
buf.write("\3\2\2\2\u0195\u0196\3\2\2\2\u0196\u0199\3\2\2\2\u0197")
buf.write("\u0195\3\2\2\2\u0198\u0191\3\2\2\2\u0199\u019a\3\2\2\2")
buf.write("\u019a\u0198\3\2\2\2\u019a\u019b\3\2\2\2\u019b\u019f\3")
buf.write("\2\2\2\u019c\u019e\7y\2\2\u019d\u019c\3\2\2\2\u019e\u01a1")
buf.write("\3\2\2\2\u019f\u019d\3\2\2\2\u019f\u01a0\3\2\2\2\u01a0")
buf.write("\5\3\2\2\2\u01a1\u019f\3\2\2\2\u01a2\u01a7\5\n\6\2\u01a3")
buf.write("\u01a7\5\b\5\2\u01a4\u01a7\5\f\7\2\u01a5\u01a7\5\16\b")
buf.write("\2\u01a6\u01a2\3\2\2\2\u01a6\u01a3\3\2\2\2\u01a6\u01a4")
buf.write("\3\2\2\2\u01a6\u01a5\3\2\2\2\u01a7\7\3\2\2\2\u01a8\u01aa")
buf.write("\5\24\13\2\u01a9\u01a8\3\2\2\2\u01a9\u01aa\3\2\2\2\u01aa")
buf.write("\u01ab\3\2\2\2\u01ab\u01ac\5\"\22\2\u01ac\t\3\2\2\2\u01ad")
buf.write("\u01ae\5\30\r\2\u01ae\u01af\5\"\22\2\u01af\13\3\2\2\2")
buf.write("\u01b0\u01b1\5\34\17\2\u01b1\u01b2\5\"\22\2\u01b2\r\3")
buf.write("\2\2\2\u01b3\u01b4\5\32\16\2\u01b4\u01b5\5\"\22\2\u01b5")
buf.write("\17\3\2\2\2\u01b6\u01bb\5(\25\2\u01b7\u01bb\5\62\32\2")
buf.write("\u01b8\u01bb\5t;\2\u01b9\u01bb\5v<\2\u01ba\u01b6\3\2\2")
buf.write("\2\u01ba\u01b7\3\2\2\2\u01ba\u01b8\3\2\2\2\u01ba\u01b9")
buf.write("\3\2\2\2\u01bb\21\3\2\2\2\u01bc\u01cf\5\u00c2b\2\u01bd")
buf.write("\u01cf\5\u008eH\2\u01be\u01cf\5\u009aN\2\u01bf\u01cf\5")
buf.write("\u00aaV\2\u01c0\u01cf\5\u00b6\\\2\u01c1\u01cf\5\u00b8")
buf.write("]\2\u01c2\u01cf\5\u00ba^\2\u01c3\u01cf\5\u00be`\2\u01c4")
buf.write("\u01cf\5\u00bc_\2\u01c5\u01cf\5\u00c0a\2\u01c6\u01cf\5")
buf.write("\u010e\u0088\2\u01c7\u01cf\5\u010a\u0086\2\u01c8\u01cf")
buf.write("\5\u00d0i\2\u01c9\u01cf\5\u0102\u0082\2\u01ca\u01cf\5")
buf.write("\u010c\u0087\2\u01cb\u01cf\5\u0106\u0084\2\u01cc\u01cf")
buf.write("\5\u0126\u0094\2\u01cd\u01cf\5\u012e\u0098\2\u01ce\u01bc")
buf.write("\3\2\2\2\u01ce\u01bd\3\2\2\2\u01ce\u01be\3\2\2\2\u01ce")
buf.write("\u01bf\3\2\2\2\u01ce\u01c0\3\2\2\2\u01ce\u01c1\3\2\2\2")
buf.write("\u01ce\u01c2\3\2\2\2\u01ce\u01c3\3\2\2\2\u01ce\u01c4\3")
buf.write("\2\2\2\u01ce\u01c5\3\2\2\2\u01ce\u01c6\3\2\2\2\u01ce\u01c7")
buf.write("\3\2\2\2\u01ce\u01c8\3\2\2\2\u01ce\u01c9\3\2\2\2\u01ce")
buf.write("\u01ca\3\2\2\2\u01ce\u01cb\3\2\2\2\u01ce\u01cc\3\2\2\2")
buf.write("\u01ce\u01cd\3\2\2\2\u01cf\23\3\2\2\2\u01d0\u01d1\7\3")
buf.write("\2\2\u01d1\u01d2\7u\2\2\u01d2\u01d3\7y\2\2\u01d3\25\3")
buf.write("\2\2\2\u01d4\u01d5\7\4\2\2\u01d5\u01da\7u\2\2\u01d6\u01d7")
buf.write("\7H\2\2\u01d7\u01d8\5\36\20\2\u01d8\u01d9\7I\2\2\u01d9")
buf.write("\u01db\3\2\2\2\u01da\u01d6\3\2\2\2\u01da\u01db\3\2\2\2")
buf.write("\u01db\27\3\2\2\2\u01dc\u01de\5P)\2\u01dd\u01dc\3\2\2")
buf.write("\2\u01dd\u01de\3\2\2\2\u01de\u01df\3\2\2\2\u01df\u01e0")
buf.write("\7\5\2\2\u01e0\u01e1\7u\2\2\u01e1\u01e3\7H\2\2\u01e2\u01e4")
buf.write("\5\36\20\2\u01e3\u01e2\3\2\2\2\u01e3\u01e4\3\2\2\2\u01e4")
buf.write("\u01e5\3\2\2\2\u01e5\u01e7\7I\2\2\u01e6\u01e8\7y\2\2\u01e7")
buf.write("\u01e6\3\2\2\2\u01e7\u01e8\3\2\2\2\u01e8\31\3\2\2\2\u01e9")
buf.write("\u01ea\7\6\2\2\u01ea\u01eb\7u\2\2\u01eb\33\3\2\2\2\u01ec")
buf.write("\u01ed\7\7\2\2\u01ed\u01f3\7u\2\2\u01ee\u01f0\7H\2\2\u01ef")
buf.write("\u01f1\5\36\20\2\u01f0\u01ef\3\2\2\2\u01f0\u01f1\3\2\2")
buf.write("\2\u01f1\u01f2\3\2\2\2\u01f2\u01f4\7I\2\2\u01f3\u01ee")
buf.write("\3\2\2\2\u01f3\u01f4\3\2\2\2\u01f4\u01f6\3\2\2\2\u01f5")
buf.write("\u01f7\7y\2\2\u01f6\u01f5\3\2\2\2\u01f6\u01f7\3\2\2\2")
buf.write("\u01f7\35\3\2\2\2\u01f8\u01fd\5\u0182\u00c2\2\u01f9\u01fa")
buf.write("\7G\2\2\u01fa\u01fc\5\u0182\u00c2\2\u01fb\u01f9\3\2\2")
buf.write("\2\u01fc\u01ff\3\2\2\2\u01fd\u01fb\3\2\2\2\u01fd\u01fe")
buf.write("\3\2\2\2\u01fe\37\3\2\2\2\u01ff\u01fd\3\2\2\2\u0200\u020e")
buf.write("\5\26\f\2\u0201\u020e\5X-\2\u0202\u020e\5l\67\2\u0203")
buf.write("\u020e\5B\"\2\u0204\u020e\58\35\2\u0205\u020e\5T+\2\u0206")
buf.write("\u020e\5r:\2\u0207\u020e\5\20\t\2\u0208\u020e\5z>\2\u0209")
buf.write("\u020a\5\u0122\u0092\2\u020a\u020b\5\u0122\u0092\2\u020b")
buf.write("\u020e\3\2\2\2\u020c\u020e\5\22\n\2\u020d\u0200\3\2\2")
buf.write("\2\u020d\u0201\3\2\2\2\u020d\u0202\3\2\2\2\u020d\u0203")
buf.write("\3\2\2\2\u020d\u0204\3\2\2\2\u020d\u0205\3\2\2\2\u020d")
buf.write("\u0206\3\2\2\2\u020d\u0207\3\2\2\2\u020d\u0208\3\2\2\2")
buf.write("\u020d\u0209\3\2\2\2\u020d\u020c\3\2\2\2\u020e!\3\2\2")
buf.write("\2\u020f\u0211\5\2\2\2\u0210\u020f\3\2\2\2\u0211\u0214")
buf.write("\3\2\2\2\u0212\u0210\3\2\2\2\u0212\u0213\3\2\2\2\u0213")
buf.write("\u021c\3\2\2\2\u0214\u0212\3\2\2\2\u0215\u0219\5$\23\2")
buf.write("\u0216\u0218\5\2\2\2\u0217\u0216\3\2\2\2\u0218\u021b\3")
buf.write("\2\2\2\u0219\u0217\3\2\2\2\u0219\u021a\3\2\2\2\u021a\u021d")
buf.write("\3\2\2\2\u021b\u0219\3\2\2\2\u021c\u0215\3\2\2\2\u021d")
buf.write("\u021e\3\2\2\2\u021e\u021c\3\2\2\2\u021e\u021f\3\2\2\2")
buf.write("\u021f\u0220\3\2\2\2\u0220\u0221\5&\24\2\u0221#\3\2\2")
buf.write("\2\u0222\u0224\7\62\2\2\u0223\u0222\3\2\2\2\u0223\u0224")
buf.write("\3\2\2\2\u0224\u0225\3\2\2\2\u0225\u0226\5 \21\2\u0226")
buf.write("\u0227\7y\2\2\u0227%\3\2\2\2\u0228\u022a\7\62\2\2\u0229")
buf.write("\u0228\3\2\2\2\u0229\u022a\3\2\2\2\u022a\u022b\3\2\2\2")
buf.write("\u022b\u022c\7\b\2\2\u022c\'\3\2\2\2\u022d\u022e\7\t\2")
buf.write("\2\u022e\u022f\5,\27\2\u022f)\3\2\2\2\u0230\u0231\t\2")
buf.write("\2\2\u0231\u0232\7H\2\2\u0232\u0233\5.\30\2\u0233\u0234")
buf.write("\7I\2\2\u0234+\3\2\2\2\u0235\u023a\5*\26\2\u0236\u0237")
buf.write("\7G\2\2\u0237\u0239\5*\26\2\u0238\u0236\3\2\2\2\u0239")
buf.write("\u023c\3\2\2\2\u023a\u0238\3\2\2\2\u023a\u023b\3\2\2\2")
buf.write("\u023b-\3\2\2\2\u023c\u023a\3\2\2\2\u023d\u0242\5\60\31")
buf.write("\2\u023e\u023f\7G\2\2\u023f\u0241\5\60\31\2\u0240\u023e")
buf.write("\3\2\2\2\u0241\u0244\3\2\2\2\u0242\u0240\3\2\2\2\u0242")
buf.write("\u0243\3\2\2\2\u0243/\3\2\2\2\u0244\u0242\3\2\2\2\u0245")
buf.write("\u024b\5\u014a\u00a6\2\u0246\u0249\7J\2\2\u0247\u024a")
buf.write("\5\u014a\u00a6\2\u0248\u024a\7w\2\2\u0249\u0247\3\2\2")
buf.write("\2\u0249\u0248\3\2\2\2\u024a\u024c\3\2\2\2\u024b\u0246")
buf.write("\3\2\2\2\u024b\u024c\3\2\2\2\u024c\u024f\3\2\2\2\u024d")
buf.write("\u024f\7w\2\2\u024e\u0245\3\2\2\2\u024e\u024d\3\2\2\2")
buf.write("\u024f\61\3\2\2\2\u0250\u0251\7\13\2\2\u0251\u0256\5\64")
buf.write("\33\2\u0252\u0253\7G\2\2\u0253\u0255\5\64\33\2\u0254\u0252")
buf.write("\3\2\2\2\u0255\u0258\3\2\2\2\u0256\u0254\3\2\2\2\u0256")
buf.write("\u0257\3\2\2\2\u0257\63\3\2\2\2\u0258\u0256\3\2\2\2\u0259")
buf.write("\u025a\7H\2\2\u025a\u025f\5\66\34\2\u025b\u025c\7G\2\2")
buf.write("\u025c\u025e\5\66\34\2\u025d\u025b\3\2\2\2\u025e\u0261")
buf.write("\3\2\2\2\u025f\u025d\3\2\2\2\u025f\u0260\3\2\2\2\u0260")
buf.write("\u0262\3\2\2\2\u0261\u025f\3\2\2\2\u0262\u0263\7I\2\2")
buf.write("\u0263\65\3\2\2\2\u0264\u0265\5\u016c\u00b7\2\u0265\67")
buf.write("\3\2\2\2\u0266\u0270\7\f\2\2\u0267\u026c\5@!\2\u0268\u0269")
buf.write("\7G\2\2\u0269\u026b\5@!\2\u026a\u0268\3\2\2\2\u026b\u026e")
buf.write("\3\2\2\2\u026c\u026a\3\2\2\2\u026c\u026d\3\2\2\2\u026d")
buf.write("\u0271\3\2\2\2\u026e\u026c\3\2\2\2\u026f\u0271\5> \2\u0270")
buf.write("\u0267\3\2\2\2\u0270\u026f\3\2\2\2\u02719\3\2\2\2\u0272")
buf.write("\u0276\7N\2\2\u0273\u0274\7u\2\2\u0274\u0277\7N\2\2\u0275")
buf.write("\u0277\7N\2\2\u0276\u0273\3\2\2\2\u0276\u0275\3\2\2\2")
buf.write("\u0277;\3\2\2\2\u0278\u027b\7u\2\2\u0279\u027b\5*\26\2")
buf.write("\u027a\u0278\3\2\2\2\u027a\u0279\3\2\2\2\u027b=\3\2\2")
buf.write("\2\u027c\u0281\5<\37\2\u027d\u027e\7G\2\2\u027e\u0280")
buf.write("\5<\37\2\u027f\u027d\3\2\2\2\u0280\u0283\3\2\2\2\u0281")
buf.write("\u027f\3\2\2\2\u0281\u0282\3\2\2\2\u0282?\3\2\2\2\u0283")
buf.write("\u0281\3\2\2\2\u0284\u0285\5:\36\2\u0285\u0286\5> \2\u0286")
buf.write("A\3\2\2\2\u0287\u0288\5N(\2\u0288\u0289\5D#\2\u0289\u028e")
buf.write("\3\2\2\2\u028a\u028b\5h\65\2\u028b\u028c\5H%\2\u028c\u028e")
buf.write("\3\2\2\2\u028d\u0287\3\2\2\2\u028d\u028a\3\2\2\2\u028e")
buf.write("C\3\2\2\2\u028f\u0294\5F$\2\u0290\u0291\7G\2\2\u0291\u0293")
buf.write("\5F$\2\u0292\u0290\3\2\2\2\u0293\u0296\3\2\2\2\u0294\u0292")
buf.write("\3\2\2\2\u0294\u0295\3\2\2\2\u0295E\3\2\2\2\u0296\u0294")
buf.write("\3\2\2\2\u0297\u029a\7u\2\2\u0298\u029a\5*\26\2\u0299")
buf.write("\u0297\3\2\2\2\u0299\u0298\3\2\2\2\u029aG\3\2\2\2\u029b")
buf.write("\u02a0\5J&\2\u029c\u029d\7G\2\2\u029d\u029f\5J&\2\u029e")
buf.write("\u029c\3\2\2\2\u029f\u02a2\3\2\2\2\u02a0\u029e\3\2\2\2")
buf.write("\u02a0\u02a1\3\2\2\2\u02a1I\3\2\2\2\u02a2\u02a0\3\2\2")
buf.write("\2\u02a3\u02a5\5F$\2\u02a4\u02a6\5L\'\2\u02a5\u02a4\3")
buf.write("\2\2\2\u02a5\u02a6\3\2\2\2\u02a6K\3\2\2\2\u02a7\u02a8")
buf.write("\7w\2\2\u02a8\u02a9\5f\64\2\u02a9M\3\2\2\2\u02aa\u02ba")
buf.write("\7\n\2\2\u02ab\u02b0\7n\2\2\u02ac\u02ae\7w\2\2\u02ad\u02af")
buf.write("\7t\2\2\u02ae\u02ad\3\2\2\2\u02ae\u02af\3\2\2\2\u02af")
buf.write("\u02b1\3\2\2\2\u02b0\u02ac\3\2\2\2\u02b0\u02b1\3\2\2\2")
buf.write("\u02b1\u02ba\3\2\2\2\u02b2\u02b3\7/\2\2\u02b3\u02ba\7")
buf.write("n\2\2\u02b4\u02b5\7/\2\2\u02b5\u02ba\7o\2\2\u02b6\u02ba")
buf.write("\7p\2\2\u02b7\u02ba\7q\2\2\u02b8\u02ba\7\20\2\2\u02b9")
buf.write("\u02aa\3\2\2\2\u02b9\u02ab\3\2\2\2\u02b9\u02b2\3\2\2\2")
buf.write("\u02b9\u02b4\3\2\2\2\u02b9\u02b6\3\2\2\2\u02b9\u02b7\3")
buf.write("\2\2\2\u02b9\u02b8\3\2\2\2\u02baO\3\2\2\2\u02bb\u02be")
buf.write("\5N(\2\u02bc\u02be\5h\65\2\u02bd\u02bb\3\2\2\2\u02bd\u02bc")
buf.write("\3\2\2\2\u02beQ\3\2\2\2\u02bf\u02c0\7w\2\2\u02c0\u02c1")
buf.write("\7t\2\2\u02c1S\3\2\2\2\u02c2\u02c3\7\r\2\2\u02c3\u02c8")
buf.write("\5V,\2\u02c4\u02c5\7G\2\2\u02c5\u02c7\5V,\2\u02c6\u02c4")
buf.write("\3\2\2\2\u02c7\u02ca\3\2\2\2\u02c8\u02c6\3\2\2\2\u02c8")
buf.write("\u02c9\3\2\2\2\u02c9U\3\2\2\2\u02ca\u02c8\3\2\2\2\u02cb")
buf.write("\u02cc\7H\2\2\u02cc\u02cd\7u\2\2\u02cd\u02ce\7G\2\2\u02ce")
buf.write("\u02cf\7u\2\2\u02cf\u02d0\7I\2\2\u02d0W\3\2\2\2\u02d1")
buf.write("\u02d4\7\16\2\2\u02d2\u02d5\5^\60\2\u02d3\u02d5\5\\/\2")
buf.write("\u02d4\u02d2\3\2\2\2\u02d4\u02d3\3\2\2\2\u02d5Y\3\2\2")
buf.write("\2\u02d6\u02d7\5P)\2\u02d7\u02d8\7H\2\2\u02d8\u02d9\5")
buf.write("d\63\2\u02d9\u02da\7I\2\2\u02da[\3\2\2\2\u02db\u02e0\5")
buf.write("Z.\2\u02dc\u02dd\7G\2\2\u02dd\u02df\5Z.\2\u02de\u02dc")
buf.write("\3\2\2\2\u02df\u02e2\3\2\2\2\u02e0\u02de\3\2\2\2\u02e0")
buf.write("\u02e1\3\2\2\2\u02e1]\3\2\2\2\u02e2\u02e0\3\2\2\2\u02e3")
buf.write("\u02e4\7\17\2\2\u02e4_\3\2\2\2\u02e5\u02e6\7u\2\2\u02e6")
buf.write("a\3\2\2\2\u02e7\u02ea\5`\61\2\u02e8\u02e9\7L\2\2\u02e9")
buf.write("\u02eb\5`\61\2\u02ea\u02e8\3\2\2\2\u02ea\u02eb\3\2\2\2")
buf.write("\u02ebc\3\2\2\2\u02ec\u02f1\5b\62\2\u02ed\u02ee\7G\2\2")
buf.write("\u02ee\u02f0\5b\62\2\u02ef\u02ed\3\2\2\2\u02f0\u02f3\3")
buf.write("\2\2\2\u02f1\u02ef\3\2\2\2\u02f1\u02f2\3\2\2\2\u02f2e")
buf.write("\3\2\2\2\u02f3\u02f1\3\2\2\2\u02f4\u02f5\7H\2\2\u02f5")
buf.write("\u02f6\7w\2\2\u02f6\u02f7\7I\2\2\u02f7\u02f8\3\2\2\2\u02f8")
buf.write("\u02f9\7H\2\2\u02f9\u02fa\7w\2\2\u02fa\u0301\7I\2\2\u02fb")
buf.write("\u0301\7t\2\2\u02fc\u02fd\7H\2\2\u02fd\u02fe\5\u015e\u00b0")
buf.write("\2\u02fe\u02ff\7I\2\2\u02ff\u0301\3\2\2\2\u0300\u02f4")
buf.write("\3\2\2\2\u0300\u02fb\3\2\2\2\u0300\u02fc\3\2\2\2\u0301")
buf.write("g\3\2\2\2\u0302\u0304\5\u0160\u00b1\2\u0303\u0305\5j\66")
buf.write("\2\u0304\u0303\3\2\2\2\u0304\u0305\3\2\2\2\u0305i\3\2")
buf.write("\2\2\u0306\u0307\7w\2\2\u0307\u0308\5f\64\2\u0308k\3\2")
buf.write("\2\2\u0309\u030a\7\21\2\2\u030a\u030b\7H\2\2\u030b\u030c")
buf.write("\5n8\2\u030c\u030d\7I\2\2\u030dm\3\2\2\2\u030e\u0313\5")
buf.write("p9\2\u030f\u0310\7G\2\2\u0310\u0312\5p9\2\u0311\u030f")
buf.write("\3\2\2\2\u0312\u0315\3\2\2\2\u0313\u0311\3\2\2\2\u0313")
buf.write("\u0314\3\2\2\2\u0314o\3\2\2\2\u0315\u0313\3\2\2\2\u0316")
buf.write("\u0317\7u\2\2\u0317\u0318\7K\2\2\u0318\u0319\5\u0154\u00ab")
buf.write("\2\u0319q\3\2\2\2\u031a\u031b\7\22\2\2\u031b\u031c\5\36")
buf.write("\20\2\u031cs\3\2\2\2\u031d\u031e\7\23\2\2\u031e\u031f")
buf.write("\5\36\20\2\u031fu\3\2\2\2\u0320\u0329\7\24\2\2\u0321\u0326")
buf.write("\5x=\2\u0322\u0323\7G\2\2\u0323\u0325\5x=\2\u0324\u0322")
buf.write("\3\2\2\2\u0325\u0328\3\2\2\2\u0326\u0324\3\2\2\2\u0326")
buf.write("\u0327\3\2\2\2\u0327\u032a\3\2\2\2\u0328\u0326\3\2\2\2")
buf.write("\u0329\u0321\3\2\2\2\u0329\u032a\3\2\2\2\u032aw\3\2\2")
buf.write("\2\u032b\u0330\7u\2\2\u032c\u032d\7N\2\2\u032d\u032e\7")
buf.write("u\2\2\u032e\u0330\7N\2\2\u032f\u032b\3\2\2\2\u032f\u032c")
buf.write("\3\2\2\2\u0330y\3\2\2\2\u0331\u0332\7\25\2\2\u0332\u0339")
buf.write("\5\u0080A\2\u0333\u0335\7G\2\2\u0334\u0333\3\2\2\2\u0334")
buf.write("\u0335\3\2\2\2\u0335\u0336\3\2\2\2\u0336\u0338\5\u0080")
buf.write("A\2\u0337\u0334\3\2\2\2\u0338\u033b\3\2\2\2\u0339\u0337")
buf.write("\3\2\2\2\u0339\u033a\3\2\2\2\u033a{\3\2\2\2\u033b\u0339")
buf.write("\3\2\2\2\u033c\u033f\5\u016c\u00b7\2\u033d\u033f\5\u0086")
buf.write("D\2\u033e\u033c\3\2\2\2\u033e\u033d\3\2\2\2\u033f}\3\2")
buf.write("\2\2\u0340\u0341\t\3\2\2\u0341\u0343\7w\2\2\u0342\u0340")
buf.write("\3\2\2\2\u0342\u0343\3\2\2\2\u0343\u0346\3\2\2\2\u0344")
buf.write("\u0347\5\u017a\u00be\2\u0345\u0347\7u\2\2\u0346\u0344")
buf.write("\3\2\2\2\u0346\u0345\3\2\2\2\u0347\177\3\2\2\2\u0348\u0349")
buf.write("\5\u0082B\2\u0349\u034a\5\u0084C\2\u034a\u0081\3\2\2\2")
buf.write("\u034b\u0350\5|?\2\u034c\u034d\7G\2\2\u034d\u034f\5|?")
buf.write("\2\u034e\u034c\3\2\2\2\u034f\u0352\3\2\2\2\u0350\u034e")
buf.write("\3\2\2\2\u0350\u0351\3\2\2\2\u0351\u0353\3\2\2\2\u0352")
buf.write("\u0350\3\2\2\2\u0353\u0354\7N\2\2\u0354\u0083\3\2\2\2")
buf.write("\u0355\u035a\5~@\2\u0356\u0357\7G\2\2\u0357\u0359\5~@")
buf.write("\2\u0358\u0356\3\2\2\2\u0359\u035c\3\2\2\2\u035a\u0358")
buf.write("\3\2\2\2\u035a\u035b\3\2\2\2\u035b\u035d\3\2\2\2\u035c")
buf.write("\u035a\3\2\2\2\u035d\u035e\7N\2\2\u035e\u0085\3\2\2\2")
buf.write("\u035f\u0360\7H\2\2\u0360\u0361\5\u008aF\2\u0361\u0362")
buf.write("\7G\2\2\u0362\u0363\5\u0088E\2\u0363\u0364\7I\2\2\u0364")
buf.write("\u0087\3\2\2\2\u0365\u0366\7u\2\2\u0366\u0367\7K\2\2\u0367")
buf.write("\u0368\5\u015e\u00b0\2\u0368\u0369\7G\2\2\u0369\u036c")
buf.write("\5\u015e\u00b0\2\u036a\u036b\7G\2\2\u036b\u036d\5\u015e")
buf.write("\u00b0\2\u036c\u036a\3\2\2\2\u036c\u036d\3\2\2\2\u036d")
buf.write("\u0089\3\2\2\2\u036e\u0372\5\u008cG\2\u036f\u0370\7G\2")
buf.write("\2\u0370\u0372\5\u008aF\2\u0371\u036e\3\2\2\2\u0371\u036f")
buf.write("\3\2\2\2\u0372\u008b\3\2\2\2\u0373\u0376\5\u016c\u00b7")
buf.write("\2\u0374\u0376\5\u0086D\2\u0375\u0373\3\2\2\2\u0375\u0374")
buf.write("\3\2\2\2\u0376\u008d\3\2\2\2\u0377\u0378\t\4\2\2\u0378")
buf.write("\u0379\5\u0184\u00c3\2\u0379\u037d\3\2\2\2\u037a\u037e")
buf.write("\5\u0090I\2\u037b\u037e\5\u0092J\2\u037c\u037e\5\u0098")
buf.write("M\2\u037d\u037a\3\2\2\2\u037d\u037b\3\2\2\2\u037d\u037c")
buf.write("\3\2\2\2\u037e\u008f\3\2\2\2\u037f\u0380\5\u0094K\2\u0380")
buf.write("\u0091\3\2\2\2\u0381\u0382\7H\2\2\u0382\u0383\5\u0096")
buf.write("L\2\u0383\u0385\7I\2\2\u0384\u0386\7G\2\2\u0385\u0384")
buf.write("\3\2\2\2\u0385\u0386\3\2\2\2\u0386\u0387\3\2\2\2\u0387")
buf.write("\u0388\5\u0158\u00ad\2\u0388\u0093\3\2\2\2\u0389\u038a")
buf.write("\7t\2\2\u038a\u0095\3\2\2\2\u038b\u0390\5\u0094K\2\u038c")
buf.write("\u038d\7G\2\2\u038d\u038f\5\u0094K\2\u038e\u038c\3\2\2")
buf.write("\2\u038f\u0392\3\2\2\2\u0390\u038e\3\2\2\2\u0390\u0391")
buf.write("\3\2\2\2\u0391\u0097\3\2\2\2\u0392\u0390\3\2\2\2\u0393")
buf.write("\u039b\7u\2\2\u0394\u0396\7G\2\2\u0395\u0394\3\2\2\2\u0395")
buf.write("\u0396\3\2\2\2\u0396\u0397\3\2\2\2\u0397\u0398\7H\2\2")
buf.write("\u0398\u0399\5\u0096L\2\u0399\u039a\7I\2\2\u039a\u039c")
buf.write("\3\2\2\2\u039b\u0395\3\2\2\2\u039b\u039c\3\2\2\2\u039c")
buf.write("\u0099\3\2\2\2\u039d\u039e\7\30\2\2\u039e\u039f\7H\2\2")
buf.write("\u039f\u03a0\5\u0164\u00b3\2\u03a0\u03a4\7I\2\2\u03a1")
buf.write("\u03a5\5\u00a0Q\2\u03a2\u03a5\5\u009eP\2\u03a3\u03a5\5")
buf.write("\u009cO\2\u03a4\u03a1\3\2\2\2\u03a4\u03a2\3\2\2\2\u03a4")
buf.write("\u03a3\3\2\2\2\u03a5\u009b\3\2\2\2\u03a6\u03a7\5\u0094")
buf.write("K\2\u03a7\u03a8\7G\2\2\u03a8\u03a9\5\u0094K\2\u03a9\u03aa")
buf.write("\7G\2\2\u03aa\u03ab\5\u0094K\2\u03ab\u009d\3\2\2\2\u03ac")
buf.write("\u03ad\5\22\n\2\u03ad\u009f\3\2\2\2\u03ae\u03b2\5\u00a2")
buf.write("R\2\u03af\u03b1\5\u00a4S\2\u03b0\u03af\3\2\2\2\u03b1\u03b4")
buf.write("\3\2\2\2\u03b2\u03b0\3\2\2\2\u03b2\u03b3\3\2\2\2\u03b3")
buf.write("\u03b6\3\2\2\2\u03b4\u03b2\3\2\2\2\u03b5\u03b7\5\u00a6")
buf.write("T\2\u03b6\u03b5\3\2\2\2\u03b6\u03b7\3\2\2\2\u03b7\u03b8")
buf.write("\3\2\2\2\u03b8\u03b9\5\u00a8U\2\u03b9\u00a1\3\2\2\2\u03ba")
buf.write("\u03bc\7\31\2\2\u03bb\u03bd\7y\2\2\u03bc\u03bb\3\2\2\2")
buf.write("\u03bc\u03bd\3\2\2\2\u03bd\u03c1\3\2\2\2\u03be\u03c0\5")
buf.write("\2\2\2\u03bf\u03be\3\2\2\2\u03c0\u03c3\3\2\2\2\u03c1\u03bf")
buf.write("\3\2\2\2\u03c1\u03c2\3\2\2\2\u03c2\u03cb\3\2\2\2\u03c3")
buf.write("\u03c1\3\2\2\2\u03c4\u03c8\5$\23\2\u03c5\u03c7\5\2\2\2")
buf.write("\u03c6\u03c5\3\2\2\2\u03c7\u03ca\3\2\2\2\u03c8\u03c6\3")
buf.write("\2\2\2\u03c8\u03c9\3\2\2\2\u03c9\u03cc\3\2\2\2\u03ca\u03c8")
buf.write("\3\2\2\2\u03cb\u03c4\3\2\2\2\u03cc\u03cd\3\2\2\2\u03cd")
buf.write("\u03cb\3\2\2\2\u03cd\u03ce\3\2\2\2\u03ce\u00a3\3\2\2\2")
buf.write("\u03cf\u03d3\7\34\2\2\u03d0\u03d1\7\32\2\2\u03d1\u03d3")
buf.write("\7\30\2\2\u03d2\u03cf\3\2\2\2\u03d2\u03d0\3\2\2\2\u03d3")
buf.write("\u03d4\3\2\2\2\u03d4\u03d5\7H\2\2\u03d5\u03d6\5\u0164")
buf.write("\u00b3\2\u03d6\u03d7\7I\2\2\u03d7\u03d9\7\31\2\2\u03d8")
buf.write("\u03da\7y\2\2\u03d9\u03d8\3\2\2\2\u03d9\u03da\3\2\2\2")
buf.write("\u03da\u03dc\3\2\2\2\u03db\u03dd\5$\23\2\u03dc\u03db\3")
buf.write("\2\2\2\u03dd\u03de\3\2\2\2\u03de\u03dc\3\2\2\2\u03de\u03df")
buf.write("\3\2\2\2\u03df\u00a5\3\2\2\2\u03e0\u03e2\7\32\2\2\u03e1")
buf.write("\u03e3\7y\2\2\u03e2\u03e1\3\2\2\2\u03e2\u03e3\3\2\2\2")
buf.write("\u03e3\u03e7\3\2\2\2\u03e4\u03e6\5\2\2\2\u03e5\u03e4\3")
buf.write("\2\2\2\u03e6\u03e9\3\2\2\2\u03e7\u03e5\3\2\2\2\u03e7\u03e8")
buf.write("\3\2\2\2\u03e8\u03f1\3\2\2\2\u03e9\u03e7\3\2\2\2\u03ea")
buf.write("\u03ee\5$\23\2\u03eb\u03ed\5\2\2\2\u03ec\u03eb\3\2\2\2")
buf.write("\u03ed\u03f0\3\2\2\2\u03ee\u03ec\3\2\2\2\u03ee\u03ef\3")
buf.write("\2\2\2\u03ef\u03f2\3\2\2\2\u03f0\u03ee\3\2\2\2\u03f1\u03ea")
buf.write("\3\2\2\2\u03f2\u03f3\3\2\2\2\u03f3\u03f1\3\2\2\2\u03f3")
buf.write("\u03f4\3\2\2\2\u03f4\u00a7\3\2\2\2\u03f5\u03f9\7\33\2")
buf.write("\2\u03f6\u03f7\7\b\2\2\u03f7\u03f9\7\30\2\2\u03f8\u03f5")
buf.write("\3\2\2\2\u03f8\u03f6\3\2\2\2\u03f9\u00a9\3\2\2\2\u03fa")
buf.write("\u03fd\7\35\2\2\u03fb\u03fe\5\u00aeX\2\u03fc\u03fe\5\u00b2")
buf.write("Z\2\u03fd\u03fb\3\2\2\2\u03fd\u03fc\3\2\2\2\u03fe\u00ab")
buf.write("\3\2\2\2\u03ff\u0400\5\u0172\u00ba\2\u0400\u0401\7K\2")
buf.write("\2\u0401\u0402\5\u015a\u00ae\2\u0402\u0403\7G\2\2\u0403")
buf.write("\u0406\5\u015a\u00ae\2\u0404\u0405\7G\2\2\u0405\u0407")
buf.write("\5\u015a\u00ae\2\u0406\u0404\3\2\2\2\u0406\u0407\3\2\2")
buf.write("\2\u0407\u00ad\3\2\2\2\u0408\u040a\5\u0094K\2\u0409\u040b")
buf.write("\7G\2\2\u040a\u0409\3\2\2\2\u040a\u040b\3\2\2\2\u040b")
buf.write("\u040c\3\2\2\2\u040c\u040e\5\u00acW\2\u040d\u040f\7y\2")
buf.write("\2\u040e\u040d\3\2\2\2\u040e\u040f\3\2\2\2\u040f\u0410")
buf.write("\3\2\2\2\u0410\u0412\5\u00b0Y\2\u0411\u0413\7y\2\2\u0412")
buf.write("\u0411\3\2\2\2\u0412\u0413\3\2\2\2\u0413\u0414\3\2\2\2")
buf.write("\u0414\u0415\5\u00b6\\\2\u0415\u00af\3\2\2\2\u0416\u0418")
buf.write("\5$\23\2\u0417\u0416\3\2\2\2\u0418\u0419\3\2\2\2\u0419")
buf.write("\u0417\3\2\2\2\u0419\u041a\3\2\2\2\u041a\u00b1\3\2\2\2")
buf.write("\u041b\u041d\5\u00acW\2\u041c\u041e\7y\2\2\u041d\u041c")
buf.write("\3\2\2\2\u041d\u041e\3\2\2\2\u041e\u041f\3\2\2\2\u041f")
buf.write("\u0421\5\u00b0Y\2\u0420\u0422\7y\2\2\u0421\u0420\3\2\2")
buf.write("\2\u0421\u0422\3\2\2\2\u0422\u0423\3\2\2\2\u0423\u0424")
buf.write("\5\u00b4[\2\u0424\u00b3\3\2\2\2\u0425\u0429\7 \2\2\u0426")
buf.write("\u0427\7\b\2\2\u0427\u0429\7\35\2\2\u0428\u0425\3\2\2")
buf.write("\2\u0428\u0426\3\2\2\2\u0429\u00b5\3\2\2\2\u042a\u042c")
buf.write("\5\u0094K\2\u042b\u042a\3\2\2\2\u042c\u042f\3\2\2\2\u042d")
buf.write("\u042b\3\2\2\2\u042d\u042e\3\2\2\2\u042e\u0430\3\2\2\2")
buf.write("\u042f\u042d\3\2\2\2\u0430\u0431\7\36\2\2\u0431\u00b7")
buf.write("\3\2\2\2\u0432\u0434\7\37\2\2\u0433\u0435\t\5\2\2\u0434")
buf.write("\u0433\3\2\2\2\u0434\u0435\3\2\2\2\u0435\u00b9\3\2\2\2")
buf.write("\u0436\u0437\7!\2\2\u0437\u0438\t\5\2\2\u0438\u00bb\3")
buf.write("\2\2\2\u0439\u043a\7\"\2\2\u043a\u043b\7H\2\2\u043b\u043c")
buf.write("\5\u00c4c\2\u043c\u0445\7I\2\2\u043d\u043f\7G\2\2\u043e")
buf.write("\u043d\3\2\2\2\u043e\u043f\3\2\2\2\u043f\u0440\3\2\2\2")
buf.write("\u0440\u0442\5\u00caf\2\u0441\u043e\3\2\2\2\u0442\u0443")
buf.write("\3\2\2\2\u0443\u0441\3\2\2\2\u0443\u0444\3\2\2\2\u0444")
buf.write("\u0446\3\2\2\2\u0445\u0441\3\2\2\2\u0445\u0446\3\2\2\2")
buf.write("\u0446\u00bd\3\2\2\2\u0447\u0448\7#\2\2\u0448\u044f\5")
buf.write("\u0116\u008c\2\u0449\u044a\7G\2\2\u044a\u044c\5\u00ca")
buf.write("f\2\u044b\u0449\3\2\2\2\u044c\u044d\3\2\2\2\u044d\u044b")
buf.write("\3\2\2\2\u044d\u044e\3\2\2\2\u044e\u0450\3\2\2\2\u044f")
buf.write("\u044b\3\2\2\2\u044f\u0450\3\2\2\2\u0450\u00bf\3\2\2\2")
buf.write("\u0451\u0452\7$\2\2\u0452\u0459\5\u0116\u008c\2\u0453")
buf.write("\u0454\7G\2\2\u0454\u0456\5\u00caf\2\u0455\u0453\3\2\2")
buf.write("\2\u0456\u0457\3\2\2\2\u0457\u0455\3\2\2\2\u0457\u0458")
buf.write("\3\2\2\2\u0458\u045a\3\2\2\2\u0459\u0455\3\2\2\2\u0459")
buf.write("\u045a\3\2\2\2\u045a\u00c1\3\2\2\2\u045b\u045c\5\u016c")
buf.write("\u00b7\2\u045c\u045d\7K\2\2\u045d\u045e\5\u0130\u0099")
buf.write("\2\u045e\u00c3\3\2\2\2\u045f\u0464\5\u00c8e\2\u0460\u0461")
buf.write("\7G\2\2\u0461\u0463\5\u00c8e\2\u0462\u0460\3\2\2\2\u0463")
buf.write("\u0466\3\2\2\2\u0464\u0462\3\2\2\2\u0464\u0465\3\2\2\2")
buf.write("\u0465\u00c5\3\2\2\2\u0466\u0464\3\2\2\2\u0467\u0468\5")
buf.write("\u00dco\2\u0468\u046b\7K\2\2\u0469\u046c\5\u0094K\2\u046a")
buf.write("\u046c\7u\2\2\u046b\u0469\3\2\2\2\u046b\u046a\3\2\2\2")
buf.write("\u046c\u00c7\3\2\2\2\u046d\u0485\5\u0114\u008b\2\u046e")
buf.write("\u0485\t\6\2\2\u046f\u0470\5\u00d4k\2\u0470\u0471\7K\2")
buf.write("\2\u0471\u0472\5\u0116\u008c\2\u0472\u0485\3\2\2\2\u0473")
buf.write("\u0474\5\u00d6l\2\u0474\u0475\7K\2\2\u0475\u0476\5\u0114")
buf.write("\u008b\2\u0476\u0485\3\2\2\2\u0477\u0478\5\u00d8m\2\u0478")
buf.write("\u0479\7K\2\2\u0479\u047a\5\u0158\u00ad\2\u047a\u0485")
buf.write("\3\2\2\2\u047b\u047c\5\u00dan\2\u047c\u047d\7K\2\2\u047d")
buf.write("\u047e\5\u0094K\2\u047e\u0485\3\2\2\2\u047f\u0485\5\u00c6")
buf.write("d\2\u0480\u0481\5\u00dep\2\u0481\u0482\7K\2\2\u0482\u0483")
buf.write("\5\u016c\u00b7\2\u0483\u0485\3\2\2\2\u0484\u046d\3\2\2")
buf.write("\2\u0484\u046e\3\2\2\2\u0484\u046f\3\2\2\2\u0484\u0473")
buf.write("\3\2\2\2\u0484\u0477\3\2\2\2\u0484\u047b\3\2\2\2\u0484")
buf.write("\u047f\3\2\2\2\u0484\u0480\3\2\2\2\u0485\u00c9\3\2\2\2")
buf.write("\u0486\u0487\5\u00ccg\2\u0487\u0488\7G\2\2\u0488\u0489")
buf.write("\7u\2\2\u0489\u048a\7K\2\2\u048a\u048b\3\2\2\2\u048b\u048c")
buf.write("\5\u00ccg\2\u048c\u0497\3\2\2\2\u048d\u048e\5\u00ccg\2")
buf.write("\u048e\u048f\7G\2\2\u048f\u0490\5\u00ccg\2\u0490\u0491")
buf.write("\3\2\2\2\u0491\u0492\5\u00ccg\2\u0492\u0493\7G\2\2\u0493")
buf.write("\u0494\5\u00caf\2\u0494\u0497\3\2\2\2\u0495\u0497\5\u00cc")
buf.write("g\2\u0496\u0486\3\2\2\2\u0496\u048d\3\2\2\2\u0496\u0495")
buf.write("\3\2\2\2\u0497\u00cb\3\2\2\2\u0498\u0499\7H\2\2\u0499")
buf.write("\u049a\5\u00caf\2\u049a\u049b\7G\2\2\u049b\u049c\7u\2")
buf.write("\2\u049c\u049d\7K\2\2\u049d\u049e\3\2\2\2\u049e\u049f")
buf.write("\5\u00ceh\2\u049f\u04a2\3\2\2\2\u04a0\u04a2\5\u0130\u0099")
buf.write("\2\u04a1\u0498\3\2\2\2\u04a1\u04a0\3\2\2\2\u04a2\u00cd")
buf.write("\3\2\2\2\u04a3\u04a4\7H\2\2\u04a4\u04a5\5\u00caf\2\u04a5")
buf.write("\u04a6\7G\2\2\u04a6\u04a7\7u\2\2\u04a7\u04a8\7K\2\2\u04a8")
buf.write("\u04a9\5\u015a\u00ae\2\u04a9\u04aa\7G\2\2\u04aa\u04ad")
buf.write("\5\u015a\u00ae\2\u04ab\u04ac\7G\2\2\u04ac\u04ae\5\u015a")
buf.write("\u00ae\2\u04ad\u04ab\3\2\2\2\u04ad\u04ae\3\2\2\2\u04ae")
buf.write("\u04af\3\2\2\2\u04af\u04b0\7I\2\2\u04b0\u00cf\3\2\2\2")
buf.write("\u04b1\u04b2\7%\2\2\u04b2\u04b3\7H\2\2\u04b3\u04b8\5\u00d2")
buf.write("j\2\u04b4\u04b5\7G\2\2\u04b5\u04b7\5\u00d2j\2\u04b6\u04b4")
buf.write("\3\2\2\2\u04b7\u04ba\3\2\2\2\u04b8\u04b6\3\2\2\2\u04b8")
buf.write("\u04b9\3\2\2\2\u04b9\u04bb\3\2\2\2\u04ba\u04b8\3\2\2\2")
buf.write("\u04bb\u04bc\7I\2\2\u04bc\u00d1\3\2\2\2\u04bd\u04e3\5")
buf.write("\u0114\u008b\2\u04be\u04bf\5\u00d6l\2\u04bf\u04c0\7K\2")
buf.write("\2\u04c0\u04c1\5\u0114\u008b\2\u04c1\u04e3\3\2\2\2\u04c2")
buf.write("\u04e3\5\u00c6d\2\u04c3\u04c4\5\u00e0q\2\u04c4\u04c5\7")
buf.write("K\2\2\u04c5\u04c6\5\u0160\u00b1\2\u04c6\u04e3\3\2\2\2")
buf.write("\u04c7\u04c8\5\u00e2r\2\u04c8\u04c9\7K\2\2\u04c9\u04ca")
buf.write("\5\u0160\u00b1\2\u04ca\u04e3\3\2\2\2\u04cb\u04ce\5\u00e4")
buf.write("s\2\u04cc\u04ce\5\u00e6t\2\u04cd\u04cb\3\2\2\2\u04cd\u04cc")
buf.write("\3\2\2\2\u04ce\u04cf\3\2\2\2\u04cf\u04d0\7K\2\2\u04d0")
buf.write("\u04d1\5\u0160\u00b1\2\u04d1\u04e3\3\2\2\2\u04d2\u04d3")
buf.write("\5\u00e8u\2\u04d3\u04d4\7K\2\2\u04d4\u04d5\5\u0160\u00b1")
buf.write("\2\u04d5\u04e3\3\2\2\2\u04d6\u04d7\5\u00eav\2\u04d7\u04d8")
buf.write("\7K\2\2\u04d8\u04d9\5\u0158\u00ad\2\u04d9\u04e3\3\2\2")
buf.write("\2\u04da\u04db\5\u00ecw\2\u04db\u04dc\7K\2\2\u04dc\u04dd")
buf.write("\5\u0160\u00b1\2\u04dd\u04e3\3\2\2\2\u04de\u04df\5\u00de")
buf.write("p\2\u04df\u04e0\7K\2\2\u04e0\u04e1\5\u016c\u00b7\2\u04e1")
buf.write("\u04e3\3\2\2\2\u04e2\u04bd\3\2\2\2\u04e2\u04be\3\2\2\2")
buf.write("\u04e2\u04c2\3\2\2\2\u04e2\u04c3\3\2\2\2\u04e2\u04c7\3")
buf.write("\2\2\2\u04e2\u04cd\3\2\2\2\u04e2\u04d2\3\2\2\2\u04e2\u04d6")
buf.write("\3\2\2\2\u04e2\u04da\3\2\2\2\u04e2\u04de\3\2\2\2\u04e3")
buf.write("\u00d3\3\2\2\2\u04e4\u04e5\7&\2\2\u04e5\u00d5\3\2\2\2")
buf.write("\u04e6\u04e7\7\'\2\2\u04e7\u00d7\3\2\2\2\u04e8\u04e9\7")
buf.write("u\2\2\u04e9\u00d9\3\2\2\2\u04ea\u04eb\7\b\2\2\u04eb\u00db")
buf.write("\3\2\2\2\u04ec\u04ed\7(\2\2\u04ed\u00dd\3\2\2\2\u04ee")
buf.write("\u04ef\7\60\2\2\u04ef\u00df\3\2\2\2\u04f0\u04f1\7\63\2")
buf.write("\2\u04f1\u00e1\3\2\2\2\u04f2\u04f3\7\64\2\2\u04f3\u00e3")
buf.write("\3\2\2\2\u04f4\u04f5\7\65\2\2\u04f5\u00e5\3\2\2\2\u04f6")
buf.write("\u04f7\7\66\2\2\u04f7\u00e7\3\2\2\2\u04f8\u04f9\7\67\2")
buf.write("\2\u04f9\u00e9\3\2\2\2\u04fa\u04fb\78\2\2\u04fb\u00eb")
buf.write("\3\2\2\2\u04fc\u04fd\79\2\2\u04fd\u00ed\3\2\2\2\u04fe")
buf.write("\u04ff\7:\2\2\u04ff\u00ef\3\2\2\2\u0500\u0501\7;\2\2\u0501")
buf.write("\u00f1\3\2\2\2\u0502\u0503\7<\2\2\u0503\u00f3\3\2\2\2")
buf.write("\u0504\u0505\7=\2\2\u0505\u00f5\3\2\2\2\u0506\u0507\7")
buf.write("u\2\2\u0507\u00f7\3\2\2\2\u0508\u0509\7\61\2\2\u0509\u00f9")
buf.write("\3\2\2\2\u050a\u050b\7u\2\2\u050b\u00fb\3\2\2\2\u050c")
buf.write("\u050d\7?\2\2\u050d\u00fd\3\2\2\2\u050e\u050f\7@\2\2\u050f")
buf.write("\u00ff\3\2\2\2\u0510\u0511\7A\2\2\u0511\u0101\3\2\2\2")
buf.write("\u0512\u0513\7.\2\2\u0513\u0514\7H\2\2\u0514\u0519\5\u0104")
buf.write("\u0083\2\u0515\u0516\7G\2\2\u0516\u0518\5\u0104\u0083")
buf.write("\2\u0517\u0515\3\2\2\2\u0518\u051b\3\2\2\2\u0519\u0517")
buf.write("\3\2\2\2\u0519\u051a\3\2\2\2\u051a\u051c\3\2\2\2\u051b")
buf.write("\u0519\3\2\2\2\u051c\u051d\7I\2\2\u051d\u0103\3\2\2\2")
buf.write("\u051e\u052d\5\u0114\u008b\2\u051f\u0520\5\u00d6l\2\u0520")
buf.write("\u0521\7K\2\2\u0521\u0522\5\u0114\u008b\2\u0522\u052d")
buf.write("\3\2\2\2\u0523\u052d\5\u00c6d\2\u0524\u0525\5\u00e2r\2")
buf.write("\u0525\u0526\7K\2\2\u0526\u0527\5\u0160\u00b1\2\u0527")
buf.write("\u052d\3\2\2\2\u0528\u0529\5\u00dep\2\u0529\u052a\7K\2")
buf.write("\2\u052a\u052b\5\u016c\u00b7\2\u052b\u052d\3\2\2\2\u052c")
buf.write("\u051e\3\2\2\2\u052c\u051f\3\2\2\2\u052c\u0523\3\2\2\2")
buf.write("\u052c\u0524\3\2\2\2\u052c\u0528\3\2\2\2\u052d\u0105\3")
buf.write("\2\2\2\u052e\u052f\7B\2\2\u052f\u0530\7H\2\2\u0530\u0535")
buf.write("\5\u0108\u0085\2\u0531\u0532\7G\2\2\u0532\u0534\5\u0108")
buf.write("\u0085\2\u0533\u0531\3\2\2\2\u0534\u0537\3\2\2\2\u0535")
buf.write("\u0533\3\2\2\2\u0535\u0536\3\2\2\2\u0536\u0538\3\2\2\2")
buf.write("\u0537\u0535\3\2\2\2\u0538\u0539\7I\2\2\u0539\u0107\3")
buf.write("\2\2\2\u053a\u053b\5\u00d6l\2\u053b\u053c\7K\2\2\u053c")
buf.write("\u053d\5\u0114\u008b\2\u053d\u0559\3\2\2\2\u053e\u053f")
buf.write("\5\u00e0q\2\u053f\u0540\7K\2\2\u0540\u0541\5\u0160\u00b1")
buf.write("\2\u0541\u0559\3\2\2\2\u0542\u0559\5\u00c6d\2\u0543\u0553")
buf.write("\5\u00dep\2\u0544\u0553\5\u00eex\2\u0545\u0553\5\u00f0")
buf.write("y\2\u0546\u0553\5\u00f2z\2\u0547\u0553\5\u00f4{\2\u0548")
buf.write("\u0553\5\u00f6|\2\u0549\u0553\5\u00e4s\2\u054a\u0553\5")
buf.write("\u00f8}\2\u054b\u0553\5\u00fa~\2\u054c\u0553\5\u00e8u")
buf.write("\2\u054d\u0553\5\u00fc\177\2\u054e\u0553\5\u00fe\u0080")
buf.write("\2\u054f\u0553\5\u00eav\2\u0550\u0553\5\u0100\u0081\2")
buf.write("\u0551\u0553\5\u00ecw\2\u0552\u0543\3\2\2\2\u0552\u0544")
buf.write("\3\2\2\2\u0552\u0545\3\2\2\2\u0552\u0546\3\2\2\2\u0552")
buf.write("\u0547\3\2\2\2\u0552\u0548\3\2\2\2\u0552\u0549\3\2\2\2")
buf.write("\u0552\u054a\3\2\2\2\u0552\u054b\3\2\2\2\u0552\u054c\3")
buf.write("\2\2\2\u0552\u054d\3\2\2\2\u0552\u054e\3\2\2\2\u0552\u054f")
buf.write("\3\2\2\2\u0552\u0550\3\2\2\2\u0552\u0551\3\2\2\2\u0553")
buf.write("\u0554\3\2\2\2\u0554\u0555\7K\2\2\u0555\u0556\5\u016c")
buf.write("\u00b7\2\u0556\u0559\3\2\2\2\u0557\u0559\5\u0114\u008b")
buf.write("\2\u0558\u053a\3\2\2\2\u0558\u053e\3\2\2\2\u0558\u0542")
buf.write("\3\2\2\2\u0558\u0552\3\2\2\2\u0558\u0557\3\2\2\2\u0559")
buf.write("\u0109\3\2\2\2\u055a\u055b\7C\2\2\u055b\u055c\5\u0110")
buf.write("\u0089\2\u055c\u010b\3\2\2\2\u055d\u055e\7D\2\2\u055e")
buf.write("\u055f\5\u0110\u0089\2\u055f\u010d\3\2\2\2\u0560\u0561")
buf.write("\7E\2\2\u0561\u0562\5\u0110\u0089\2\u0562\u010f\3\2\2")
buf.write("\2\u0563\u0564\5\u0114\u008b\2\u0564\u0565\5\u0114\u008b")
buf.write("\2\u0565\u0572\3\2\2\2\u0566\u0567\7H\2\2\u0567\u056c")
buf.write("\5\u0112\u008a\2\u0568\u0569\7G\2\2\u0569\u056b\5\u0112")
buf.write("\u008a\2\u056a\u0568\3\2\2\2\u056b\u056e\3\2\2\2\u056c")
buf.write("\u056a\3\2\2\2\u056c\u056d\3\2\2\2\u056d\u056f\3\2\2\2")
buf.write("\u056e\u056c\3\2\2\2\u056f\u0570\7I\2\2\u0570\u0572\3")
buf.write("\2\2\2\u0571\u0563\3\2\2\2\u0571\u0566\3\2\2\2\u0572\u0111")
buf.write("\3\2\2\2\u0573\u057e\5\u0114\u008b\2\u0574\u0575\5\u00d6")
buf.write("l\2\u0575\u0576\7K\2\2\u0576\u0577\5\u0114\u008b\2\u0577")
buf.write("\u057e\3\2\2\2\u0578\u057e\5\u00c6d\2\u0579\u057a\5\u00de")
buf.write("p\2\u057a\u057b\7K\2\2\u057b\u057c\5\u016c\u00b7\2\u057c")
buf.write("\u057e\3\2\2\2\u057d\u0573\3\2\2\2\u057d\u0574\3\2\2\2")
buf.write("\u057d\u0578\3\2\2\2\u057d\u0579\3\2\2\2\u057e\u0113\3")
buf.write("\2\2\2\u057f\u0582\5\u0148\u00a5\2\u0580\u0582\7w\2\2")
buf.write("\u0581\u057f\3\2\2\2\u0581\u0580\3\2\2\2\u0582\u0115\3")
buf.write("\2\2\2\u0583\u0587\t\6\2\2\u0584\u0587\5\u0148\u00a5\2")
buf.write("\u0585\u0587\7w\2\2\u0586\u0583\3\2\2\2\u0586\u0584\3")
buf.write("\2\2\2\u0586\u0585\3\2\2\2\u0587\u0117\3\2\2\2\u0588\u0589")
buf.write("\7*\2\2\u0589\u058a\7H\2\2\u058a\u058b\5\u011a\u008e\2")
buf.write("\u058b\u058c\7I\2\2\u058c\u0119\3\2\2\2\u058d\u0593\5")
buf.write("\u011e\u0090\2\u058e\u0590\5\u011c\u008f\2\u058f\u0591")
buf.write("\5\u011e\u0090\2\u0590\u058f\3\2\2\2\u0590\u0591\3\2\2")
buf.write("\2\u0591\u0593\3\2\2\2\u0592\u058d\3\2\2\2\u0592\u058e")
buf.write("\3\2\2\2\u0593\u05a2\3\2\2\2\u0594\u0596\5\u011c\u008f")
buf.write("\2\u0595\u0597\5\u011e\u0090\2\u0596\u0595\3\2\2\2\u0596")
buf.write("\u0597\3\2\2\2\u0597\u05a1\3\2\2\2\u0598\u059e\7G\2\2")
buf.write("\u0599\u059f\5\u011e\u0090\2\u059a\u059c\5\u011c\u008f")
buf.write("\2\u059b\u059d\5\u011e\u0090\2\u059c\u059b\3\2\2\2\u059c")
buf.write("\u059d\3\2\2\2\u059d\u059f\3\2\2\2\u059e\u0599\3\2\2\2")
buf.write("\u059e\u059a\3\2\2\2\u059f\u05a1\3\2\2\2\u05a0\u0594\3")
buf.write("\2\2\2\u05a0\u0598\3\2\2\2\u05a1\u05a4\3\2\2\2\u05a2\u05a0")
buf.write("\3\2\2\2\u05a2\u05a3\3\2\2\2\u05a3\u011b\3\2\2\2\u05a4")
buf.write("\u05a2\3\2\2\2\u05a5\u05a6\t\7\2\2\u05a6\u011d\3\2\2\2")
buf.write("\u05a7\u05b6\7_\2\2\u05a8\u05b6\5\u0120\u0091\2\u05a9")
buf.write("\u05aa\7t\2\2\u05aa\u05b6\5\u0120\u0091\2\u05ab\u05ad")
buf.write("\t\b\2\2\u05ac\u05ab\3\2\2\2\u05ac\u05ad\3\2\2\2\u05ad")
buf.write("\u05ae\3\2\2\2\u05ae\u05b3\7`\2\2\u05af\u05b1\7t\2\2\u05b0")
buf.write("\u05af\3\2\2\2\u05b0\u05b1\3\2\2\2\u05b1\u05b2\3\2\2\2")
buf.write("\u05b2\u05b4\5\u0120\u0091\2\u05b3\u05b0\3\2\2\2\u05b3")
buf.write("\u05b4\3\2\2\2\u05b4\u05b6\3\2\2\2\u05b5\u05a7\3\2\2\2")
buf.write("\u05b5\u05a8\3\2\2\2\u05b5\u05a9\3\2\2\2\u05b5\u05ac\3")
buf.write("\2\2\2\u05b6\u011f\3\2\2\2\u05b7\u05bd\t\t\2\2\u05b8\u05b9")
buf.write("\7H\2\2\u05b9\u05ba\5\u011a\u008e\2\u05ba\u05bb\7I\2\2")
buf.write("\u05bb\u05bd\3\2\2\2\u05bc\u05b7\3\2\2\2\u05bc\u05b8\3")
buf.write("\2\2\2\u05bd\u0121\3\2\2\2\u05be\u05bf\7+\2\2\u05bf\u05c0")
buf.write("\5\u0124\u0093\2\u05c0\u05c1\7K\2\2\u05c1\u05c2\5\u0130")
buf.write("\u0099\2\u05c2\u0123\3\2\2\2\u05c3\u05c4\7u\2\2\u05c4")
buf.write("\u05c5\7H\2\2\u05c5\u05c6\5\36\20\2\u05c6\u05c7\7I\2\2")
buf.write("\u05c7\u0125\3\2\2\2\u05c8\u05c9\7,\2\2\u05c9\u05ca\5")
buf.write("\u0128\u0095\2\u05ca\u0127\3\2\2\2\u05cb\u05d1\7u\2\2")
buf.write("\u05cc\u05ce\7H\2\2\u05cd\u05cf\5\u012a\u0096\2\u05ce")
buf.write("\u05cd\3\2\2\2\u05ce\u05cf\3\2\2\2\u05cf\u05d0\3\2\2\2")
buf.write("\u05d0\u05d2\7I\2\2\u05d1\u05cc\3\2\2\2\u05d1\u05d2\3")
buf.write("\2\2\2\u05d2\u0129\3\2\2\2\u05d3\u05d8\5\u012c\u0097\2")
buf.write("\u05d4\u05d5\7G\2\2\u05d5\u05d7\5\u012c\u0097\2\u05d6")
buf.write("\u05d4\3\2\2\2\u05d7\u05da\3\2\2\2\u05d8\u05d6\3\2\2\2")
buf.write("\u05d8\u05d9\3\2\2\2\u05d9\u012b\3\2\2\2\u05da\u05d8\3")
buf.write("\2\2\2\u05db\u05df\5\u0130\u0099\2\u05dc\u05dd\7w\2\2")
buf.write("\u05dd\u05df\5\u0094K\2\u05de\u05db\3\2\2\2\u05de\u05dc")
buf.write("\3\2\2\2\u05df\u012d\3\2\2\2\u05e0\u05e2\7-\2\2\u05e1")
buf.write("\u05e3\5\u0158\u00ad\2\u05e2\u05e1\3\2\2\2\u05e2\u05e3")
buf.write("\3\2\2\2\u05e3\u012f\3\2\2\2\u05e4\u05e7\5\u0132\u009a")
buf.write("\2\u05e5\u05e6\7J\2\2\u05e6\u05e8\5\u0132\u009a\2\u05e7")
buf.write("\u05e5\3\2\2\2\u05e7\u05e8\3\2\2\2\u05e8\u0131\3\2\2\2")
buf.write("\u05e9\u05ef\5\u0134\u009b\2\u05ea\u05eb\5\u0162\u00b2")
buf.write("\2\u05eb\u05ec\5\u0134\u009b\2\u05ec\u05ee\3\2\2\2\u05ed")
buf.write("\u05ea\3\2\2\2\u05ee\u05f1\3\2\2\2\u05ef\u05ed\3\2\2\2")
buf.write("\u05ef\u05f0\3\2\2\2\u05f0\u0133\3\2\2\2\u05f1\u05ef\3")
buf.write("\2\2\2\u05f2\u05f7\5\u0136\u009c\2\u05f3\u05f4\t\n\2\2")
buf.write("\u05f4\u05f6\5\u0136\u009c\2\u05f5\u05f3\3\2\2\2\u05f6")
buf.write("\u05f9\3\2\2\2\u05f7\u05f5\3\2\2\2\u05f7\u05f8\3\2\2\2")
buf.write("\u05f8\u0135\3\2\2\2\u05f9\u05f7\3\2\2\2\u05fa\u05ff\5")
buf.write("\u0138\u009d\2\u05fb\u05fc\7R\2\2\u05fc\u05fe\5\u0138")
buf.write("\u009d\2\u05fd\u05fb\3\2\2\2\u05fe\u0601\3\2\2\2\u05ff")
buf.write("\u05fd\3\2\2\2\u05ff\u0600\3\2\2\2\u0600\u0137\3\2\2\2")
buf.write("\u0601\u05ff\3\2\2\2\u0602\u0607\5\u013a\u009e\2\u0603")
buf.write("\u0604\7Q\2\2\u0604\u0606\5\u013a\u009e\2\u0605\u0603")
buf.write("\3\2\2\2\u0606\u0609\3\2\2\2\u0607\u0605\3\2\2\2\u0607")
buf.write("\u0608\3\2\2\2\u0608\u0139\3\2\2\2\u0609\u0607\3\2\2\2")
buf.write("\u060a\u060b\7P\2\2\u060b\u060e\5\u013a\u009e\2\u060c")
buf.write("\u060e\5\u013c\u009f\2\u060d\u060a\3\2\2\2\u060d\u060c")
buf.write("\3\2\2\2\u060e\u013b\3\2\2\2\u060f\u0612\5\u013e\u00a0")
buf.write("\2\u0610\u0611\t\13\2\2\u0611\u0613\5\u013e\u00a0\2\u0612")
buf.write("\u0610\3\2\2\2\u0612\u0613\3\2\2\2\u0613\u013d\3\2\2\2")
buf.write("\u0614\u0619\5\u0140\u00a1\2\u0615\u0616\t\b\2\2\u0616")
buf.write("\u0618\5\u0140\u00a1\2\u0617\u0615\3\2\2\2\u0618\u061b")
buf.write("\3\2\2\2\u0619\u0617\3\2\2\2\u0619\u061a\3\2\2\2\u061a")
buf.write("\u013f\3\2\2\2\u061b\u0619\3\2\2\2\u061c\u0621\5\u0142")
buf.write("\u00a2\2\u061d\u061e\t\f\2\2\u061e\u0620\5\u0142\u00a2")
buf.write("\2\u061f\u061d\3\2\2\2\u0620\u0623\3\2\2\2\u0621\u061f")
buf.write("\3\2\2\2\u0621\u0622\3\2\2\2\u0622\u0141\3\2\2\2\u0623")
buf.write("\u0621\3\2\2\2\u0624\u0626\t\b\2\2\u0625\u0624\3\2\2\2")
buf.write("\u0626\u0629\3\2\2\2\u0627\u0625\3\2\2\2\u0627\u0628\3")
buf.write("\2\2\2\u0628\u062a\3\2\2\2\u0629\u0627\3\2\2\2\u062a\u062b")
buf.write("\5\u0144\u00a3\2\u062b\u0143\3\2\2\2\u062c\u0631\5\u0146")
buf.write("\u00a4\2\u062d\u062e\7O\2\2\u062e\u0630\5\u0146\u00a4")
buf.write("\2\u062f\u062d\3\2\2\2\u0630\u0633\3\2\2\2\u0631\u062f")
buf.write("\3\2\2\2\u0631\u0632\3\2\2\2\u0632\u0145\3\2\2\2\u0633")
buf.write("\u0631\3\2\2\2\u0634\u063d\5\u017c\u00bf\2\u0635\u063d")
buf.write("\t\6\2\2\u0636\u063d\5\u0180\u00c1\2\u0637\u063d\5\u016c")
buf.write("\u00b7\2\u0638\u0639\7H\2\2\u0639\u063a\5\u0130\u0099")
buf.write("\2\u063a\u063b\7I\2\2\u063b\u063d\3\2\2\2\u063c\u0634")
buf.write("\3\2\2\2\u063c\u0635\3\2\2\2\u063c\u0636\3\2\2\2\u063c")
buf.write("\u0637\3\2\2\2\u063c\u0638\3\2\2\2\u063d\u0147\3\2\2\2")
buf.write("\u063e\u0643\5\u014c\u00a7\2\u063f\u0640\t\b\2\2\u0640")
buf.write("\u0642\5\u014c\u00a7\2\u0641\u063f\3\2\2\2\u0642\u0645")
buf.write("\3\2\2\2\u0643\u0641\3\2\2\2\u0643\u0644\3\2\2\2\u0644")
buf.write("\u0149\3\2\2\2\u0645\u0643\3\2\2\2\u0646\u064b\5\u014c")
buf.write("\u00a7\2\u0647\u0648\t\b\2\2\u0648\u064a\5\u014c\u00a7")
buf.write("\2\u0649\u0647\3\2\2\2\u064a\u064d\3\2\2\2\u064b\u0649")
buf.write("\3\2\2\2\u064b\u064c\3\2\2\2\u064c\u014b\3\2\2\2\u064d")
buf.write("\u064b\3\2\2\2\u064e\u0653\5\u014e\u00a8\2\u064f\u0650")
buf.write("\t\f\2\2\u0650\u0652\5\u014e\u00a8\2\u0651\u064f\3\2\2")
buf.write("\2\u0652\u0655\3\2\2\2\u0653\u0651\3\2\2\2\u0653\u0654")
buf.write("\3\2\2\2\u0654\u014d\3\2\2\2\u0655\u0653\3\2\2\2\u0656")
buf.write("\u0658\t\b\2\2\u0657\u0656\3\2\2\2\u0658\u065b\3\2\2\2")
buf.write("\u0659\u0657\3\2\2\2\u0659\u065a\3\2\2\2\u065a\u065c\3")
buf.write("\2\2\2\u065b\u0659\3\2\2\2\u065c\u065d\5\u0150\u00a9\2")
buf.write("\u065d\u014f\3\2\2\2\u065e\u0661\5\u0152\u00aa\2\u065f")
buf.write("\u0660\7O\2\2\u0660\u0662\5\u0150\u00a9\2\u0661\u065f")
buf.write("\3\2\2\2\u0661\u0662\3\2\2\2\u0662\u0151\3\2\2\2\u0663")
buf.write("\u066a\7t\2\2\u0664\u066a\5\u016e\u00b8\2\u0665\u0666")
buf.write("\7H\2\2\u0666\u0667\5\u014a\u00a6\2\u0667\u0668\7I\2\2")
buf.write("\u0668\u066a\3\2\2\2\u0669\u0663\3\2\2\2\u0669\u0664\3")
buf.write("\2\2\2\u0669\u0665\3\2\2\2\u066a\u0153\3\2\2\2\u066b\u066c")
buf.write("\5\u0130\u0099\2\u066c\u0155\3\2\2\2\u066d\u066e\5\u0130")
buf.write("\u0099\2\u066e\u0157\3\2\2\2\u066f\u0670\5\u0148\u00a5")
buf.write("\2\u0670\u0159\3\2\2\2\u0671\u0672\5\u0130\u0099\2\u0672")
buf.write("\u015b\3\2\2\2\u0673\u0674\5\u0130\u0099\2\u0674\u015d")
buf.write("\3\2\2\2\u0675\u0676\5\u0130\u0099\2\u0676\u015f\3\2\2")
buf.write("\2\u0677\u0678\5\u0130\u0099\2\u0678\u0161\3\2\2\2\u0679")
buf.write("\u067a\7N\2\2\u067a\u067b\7N\2\2\u067b\u0163\3\2\2\2\u067c")
buf.write("\u067d\5\u0130\u0099\2\u067d\u0165\3\2\2\2\u067e\u067f")
buf.write("\5\u0130\u0099\2\u067f\u0167\3\2\2\2\u0680\u0681\7u\2")
buf.write("\2\u0681\u0682\7H\2\2\u0682\u0687\5\u0158\u00ad\2\u0683")
buf.write("\u0684\7G\2\2\u0684\u0686\5\u0158\u00ad\2\u0685\u0683")
buf.write("\3\2\2\2\u0686\u0689\3\2\2\2\u0687\u0685\3\2\2\2\u0687")
buf.write("\u0688\3\2\2\2\u0688\u068a\3\2\2\2\u0689\u0687\3\2\2\2")
buf.write("\u068a\u068b\7I\2\2\u068b\u0169\3\2\2\2\u068c\u0695\7")
buf.write("H\2\2\u068d\u0692\5\u0130\u0099\2\u068e\u068f\7G\2\2\u068f")
buf.write("\u0691\5\u0130\u0099\2\u0690\u068e\3\2\2\2\u0691\u0694")
buf.write("\3\2\2\2\u0692\u0690\3\2\2\2\u0692\u0693\3\2\2\2\u0693")
buf.write("\u0696\3\2\2\2\u0694\u0692\3\2\2\2\u0695\u068d\3\2\2\2")
buf.write("\u0695\u0696\3\2\2\2\u0696\u0697\3\2\2\2\u0697\u0698\7")
buf.write("I\2\2\u0698\u016b\3\2\2\2\u0699\u069e\t\2\2\2\u069a\u069c")
buf.write("\5\u016a\u00b6\2\u069b\u069d\5\u0170\u00b9\2\u069c\u069b")
buf.write("\3\2\2\2\u069c\u069d\3\2\2\2\u069d\u069f\3\2\2\2\u069e")
buf.write("\u069a\3\2\2\2\u069e\u069f\3\2\2\2\u069f\u016d\3\2\2\2")
buf.write("\u06a0\u06a5\7u\2\2\u06a1\u06a3\5\u016a\u00b6\2\u06a2")
buf.write("\u06a4\5\u0170\u00b9\2\u06a3\u06a2\3\2\2\2\u06a3\u06a4")
buf.write("\3\2\2\2\u06a4\u06a6\3\2\2\2\u06a5\u06a1\3\2\2\2\u06a5")
buf.write("\u06a6\3\2\2\2\u06a6\u016f\3\2\2\2\u06a7\u06a9\7H\2\2")
buf.write("\u06a8\u06aa\5\u0132\u009a\2\u06a9\u06a8\3\2\2\2\u06a9")
buf.write("\u06aa\3\2\2\2\u06aa\u06ab\3\2\2\2\u06ab\u06ad\7J\2\2")
buf.write("\u06ac\u06ae\5\u0132\u009a\2\u06ad\u06ac\3\2\2\2\u06ad")
buf.write("\u06ae\3\2\2\2\u06ae\u06af\3\2\2\2\u06af\u06b0\7I\2\2")
buf.write("\u06b0\u0171\3\2\2\2\u06b1\u06b2\7u\2\2\u06b2\u0173\3")
buf.write("\2\2\2\u06b3\u06b4\7u\2\2\u06b4\u0175\3\2\2\2\u06b5\u06b6")
buf.write("\7u\2\2\u06b6\u0177\3\2\2\2\u06b7\u06b8\7u\2\2\u06b8\u0179")
buf.write("\3\2\2\2\u06b9\u06bb\t\b\2\2\u06ba\u06b9\3\2\2\2\u06ba")
buf.write("\u06bb\3\2\2\2\u06bb\u06bc\3\2\2\2\u06bc\u06c0\5\u017c")
buf.write("\u00bf\2\u06bd\u06c0\t\6\2\2\u06be\u06c0\5\u0180\u00c1")
buf.write("\2\u06bf\u06ba\3\2\2\2\u06bf\u06bd\3\2\2\2\u06bf\u06be")
buf.write("\3\2\2\2\u06c0\u017b\3\2\2\2\u06c1\u06c4\t\r\2\2\u06c2")
buf.write("\u06c4\5\u017e\u00c0\2\u06c3\u06c1\3\2\2\2\u06c3\u06c2")
buf.write("\3\2\2\2\u06c4\u017d\3\2\2\2\u06c5\u06c7\7H\2\2\u06c6")
buf.write("\u06c8\t\b\2\2\u06c7\u06c6\3\2\2\2\u06c7\u06c8\3\2\2\2")
buf.write("\u06c8\u06c9\3\2\2\2\u06c9\u06ca\t\r\2\2\u06ca\u06cc\7")
buf.write("G\2\2\u06cb\u06cd\t\b\2\2\u06cc\u06cb\3\2\2\2\u06cc\u06cd")
buf.write("\3\2\2\2\u06cd\u06ce\3\2\2\2\u06ce\u06cf\t\r\2\2\u06cf")
buf.write("\u06d0\7I\2\2\u06d0\u017f\3\2\2\2\u06d1\u06d2\t\16\2\2")
buf.write("\u06d2\u0181\3\2\2\2\u06d3\u06d4\t\2\2\2\u06d4\u0183\3")
buf.write("\2\2\2\u06d5\u06d6\7u\2\2\u06d6\u0185\3\2\2\2\u00ad\u0189")
buf.write("\u018e\u0195\u019a\u019f\u01a6\u01a9\u01ba\u01ce\u01da")
buf.write("\u01dd\u01e3\u01e7\u01f0\u01f3\u01f6\u01fd\u020d\u0212")
buf.write("\u0219\u021e\u0223\u0229\u023a\u0242\u0249\u024b\u024e")
buf.write("\u0256\u025f\u026c\u0270\u0276\u027a\u0281\u028d\u0294")
buf.write("\u0299\u02a0\u02a5\u02ae\u02b0\u02b9\u02bd\u02c8\u02d4")
buf.write("\u02e0\u02ea\u02f1\u0300\u0304\u0313\u0326\u0329\u032f")
buf.write("\u0334\u0339\u033e\u0342\u0346\u0350\u035a\u036c\u0371")
buf.write("\u0375\u037d\u0385\u0390\u0395\u039b\u03a4\u03b2\u03b6")
buf.write("\u03bc\u03c1\u03c8\u03cd\u03d2\u03d9\u03de\u03e2\u03e7")
buf.write("\u03ee\u03f3\u03f8\u03fd\u0406\u040a\u040e\u0412\u0419")
buf.write("\u041d\u0421\u0428\u042d\u0434\u043e\u0443\u0445\u044d")
buf.write("\u044f\u0457\u0459\u0464\u046b\u0484\u0496\u04a1\u04ad")
buf.write("\u04b8\u04cd\u04e2\u0519\u052c\u0535\u0552\u0558\u056c")
buf.write("\u0571\u057d\u0581\u0586\u0590\u0592\u0596\u059c\u059e")
buf.write("\u05a0\u05a2\u05ac\u05b0\u05b3\u05b5\u05bc\u05ce\u05d1")
buf.write("\u05d8\u05de\u05e2\u05e7\u05ef\u05f7\u05ff\u0607\u060d")
buf.write("\u0612\u0619\u0621\u0627\u0631\u063c\u0643\u064b\u0653")
buf.write("\u0659\u0661\u0669\u0687\u0692\u0695\u069c\u069e\u06a3")
buf.write("\u06a5\u06a9\u06ad\u06ba\u06bf\u06c3\u06c7\u06cc")
return buf.getvalue()
[docs]
class Fortran77Parser ( Parser ):
grammarFileName = "Fortran77Parser.g4"
atn = ATNDeserializer().deserialize(serializedATN())
decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
sharedContextCache = PredictionContextCache()
literalNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
"'$'", "','", "'('", "')'", "':'", "'='", "'-'", "'+'",
"'/'", "'**'", "<INVALID>", "<INVALID>", "<INVALID>",
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
"'XCON'", "'PCON'", "'FCON'", "'CCON'", "'HOLLERITH'",
"'CONCATOP'", "'CTRLDIRECT'", "'CTRLREC'", "'TO'",
"'SUBPROGRAMBLOCK'", "'DOBLOCK'", "'AIF'", "'THENBLOCK'",
"'ELSEBLOCK'", "'CODEROOT'" ]
symbolicNames = [ "<INVALID>", "PROGRAM", "ENTRY", "FUNCTION", "BLOCK",
"SUBROUTINE", "END", "DIMENSION", "REAL", "EQUIVALENCE",
"COMMON", "POINTER", "IMPLICIT", "NONE", "CHARACTER",
"PARAMETER", "EXTERNAL", "INTRINSIC", "SAVE", "DATA",
"GO", "GOTO", "IF", "THEN", "ELSE", "ENDIF", "ELSEIF",
"DO", "CONTINUE", "STOP", "ENDDO", "PAUSE", "WRITE",
"READ", "PRINT", "OPEN", "FMT", "UNIT", "ERR", "IOSTAT",
"FORMAT", "LET", "CALL", "RETURN", "CLOSE", "DOUBLE",
"IOSTART", "SEQUENTIAL", "LABEL", "FILE", "STATUS",
"ACCESS", "POSITION", "FORM", "RECL", "BLANK", "EXIST",
"OPENED", "NUMBER", "NAMED", "NAME_", "FORMATTED",
"UNFORMATTED", "NEXTREC", "INQUIRE", "BACKSPACE",
"ENDFILE", "REWIND", "DOLLAR", "COMMA", "LPAREN",
"RPAREN", "COLON", "ASSIGN", "MINUS", "PLUS", "DIV",
"POWER", "LNOT", "LAND", "LOR", "EQV", "NEQV", "XOR",
"EOR", "LT", "LE", "GT", "GE", "NE", "EQ", "TRUE",
"FALSE", "XCON", "PCON", "FCON", "CCON", "HOLLERITH",
"CONCATOP", "CTRLDIRECT", "CTRLREC", "TO", "SUBPROGRAMBLOCK",
"DOBLOCK", "AIF", "THENBLOCK", "ELSEBLOCK", "CODEROOT",
"COMPLEX", "PRECISION", "INTEGER", "LOGICAL", "SCON",
"RCON", "ICON", "NAME", "COMMENT", "STAR", "STRINGLITERAL",
"EOL", "LINECONT", "WS" ]
RULE_commentStatement = 0
RULE_program = 1
RULE_executableUnit = 2
RULE_mainProgram = 3
RULE_functionSubprogram = 4
RULE_subroutineSubprogram = 5
RULE_blockdataSubprogram = 6
RULE_otherSpecificationStatement = 7
RULE_executableStatement = 8
RULE_programStatement = 9
RULE_entryStatement = 10
RULE_functionStatement = 11
RULE_blockdataStatement = 12
RULE_subroutineStatement = 13
RULE_namelist = 14
RULE_statement = 15
RULE_subprogramBody = 16
RULE_wholeStatement = 17
RULE_endStatement = 18
RULE_dimensionStatement = 19
RULE_arrayDeclarator = 20
RULE_arrayDeclarators = 21
RULE_arrayDeclaratorExtents = 22
RULE_arrayDeclaratorExtent = 23
RULE_equivalenceStatement = 24
RULE_equivEntityGroup = 25
RULE_equivEntity = 26
RULE_commonStatement = 27
RULE_commonName = 28
RULE_commonItem = 29
RULE_commonItems = 30
RULE_commonBlock = 31
RULE_typeStatement = 32
RULE_typeStatementNameList = 33
RULE_typeStatementName = 34
RULE_typeStatementNameCharList = 35
RULE_typeStatementNameChar = 36
RULE_typeStatementLenSpec = 37
RULE_typename_ = 38
RULE_type_ = 39
RULE_typenameLen = 40
RULE_pointerStatement = 41
RULE_pointerDecl = 42
RULE_implicitStatement = 43
RULE_implicitSpec = 44
RULE_implicitSpecs = 45
RULE_implicitNone = 46
RULE_implicitLetter = 47
RULE_implicitRange = 48
RULE_implicitLetters = 49
RULE_lenSpecification = 50
RULE_characterWithLen = 51
RULE_cwlLen = 52
RULE_parameterStatement = 53
RULE_paramlist = 54
RULE_paramassign = 55
RULE_externalStatement = 56
RULE_intrinsicStatement = 57
RULE_saveStatement = 58
RULE_saveEntity = 59
RULE_dataStatement = 60
RULE_dataStatementItem = 61
RULE_dataStatementMultiple = 62
RULE_dataStatementEntity = 63
RULE_dse1 = 64
RULE_dse2 = 65
RULE_dataImpliedDo = 66
RULE_dataImpliedDoRange = 67
RULE_dataImpliedDoList = 68
RULE_dataImpliedDoListWhat = 69
RULE_gotoStatement = 70
RULE_unconditionalGoto = 71
RULE_computedGoto = 72
RULE_lblRef = 73
RULE_labelList = 74
RULE_assignedGoto = 75
RULE_ifStatement = 76
RULE_arithmeticIfStatement = 77
RULE_logicalIfStatement = 78
RULE_blockIfStatement = 79
RULE_firstIfBlock = 80
RULE_elseIfStatement = 81
RULE_elseStatement = 82
RULE_endIfStatement = 83
RULE_doStatement = 84
RULE_doVarArgs = 85
RULE_doWithLabel = 86
RULE_doBody = 87
RULE_doWithEndDo = 88
RULE_enddoStatement = 89
RULE_continueStatement = 90
RULE_stopStatement = 91
RULE_pauseStatement = 92
RULE_writeStatement = 93
RULE_readStatement = 94
RULE_printStatement = 95
RULE_assignmentStatement = 96
RULE_controlInfoList = 97
RULE_controlErrSpec = 98
RULE_controlInfoListItem = 99
RULE_ioList = 100
RULE_ioListItem = 101
RULE_ioImpliedDoList = 102
RULE_openStatement = 103
RULE_openControl = 104
RULE_controlFmt = 105
RULE_controlUnit = 106
RULE_controlRec = 107
RULE_controlEnd = 108
RULE_controlErr = 109
RULE_controlIostat = 110
RULE_controlFile = 111
RULE_controlStatus = 112
RULE_controlAccess = 113
RULE_controlPosition = 114
RULE_controlForm = 115
RULE_controlRecl = 116
RULE_controlBlank = 117
RULE_controlExist = 118
RULE_controlOpened = 119
RULE_controlNumber = 120
RULE_controlNamed = 121
RULE_controlName = 122
RULE_controlSequential = 123
RULE_controlDirect = 124
RULE_controlFormatted = 125
RULE_controlUnformatted = 126
RULE_controlNextrec = 127
RULE_closeStatement = 128
RULE_closeControl = 129
RULE_inquireStatement = 130
RULE_inquireControl = 131
RULE_backspaceStatement = 132
RULE_endfileStatement = 133
RULE_rewindStatement = 134
RULE_berFinish = 135
RULE_berFinishItem = 136
RULE_unitIdentifier = 137
RULE_formatIdentifier = 138
RULE_formatStatement = 139
RULE_fmtSpec = 140
RULE_formatsep = 141
RULE_formatedit = 142
RULE_editElement = 143
RULE_statementFunctionStatement = 144
RULE_sfArgs = 145
RULE_callStatement = 146
RULE_subroutineCall = 147
RULE_callArgumentList = 148
RULE_callArgument = 149
RULE_returnStatement = 150
RULE_expression = 151
RULE_ncExpr = 152
RULE_lexpr0 = 153
RULE_lexpr1 = 154
RULE_lexpr2 = 155
RULE_lexpr3 = 156
RULE_lexpr4 = 157
RULE_aexpr0 = 158
RULE_aexpr1 = 159
RULE_aexpr2 = 160
RULE_aexpr3 = 161
RULE_aexpr4 = 162
RULE_iexpr = 163
RULE_iexprCode = 164
RULE_iexpr1 = 165
RULE_iexpr2 = 166
RULE_iexpr3 = 167
RULE_iexpr4 = 168
RULE_constantExpr = 169
RULE_arithmeticExpression = 170
RULE_integerExpr = 171
RULE_intRealDpExpr = 172
RULE_arithmeticConstExpr = 173
RULE_intConstantExpr = 174
RULE_characterExpression = 175
RULE_concatOp = 176
RULE_logicalExpression = 177
RULE_logicalConstExpr = 178
RULE_arrayElementName = 179
RULE_subscripts = 180
RULE_varRef = 181
RULE_varRefCode = 182
RULE_substringApp = 183
RULE_variableName = 184
RULE_arrayName = 185
RULE_subroutineName = 186
RULE_functionName = 187
RULE_constant = 188
RULE_unsignedArithmeticConstant = 189
RULE_complexConstant = 190
RULE_logicalConstant = 191
RULE_identifier = 192
RULE_to = 193
ruleNames = [ "commentStatement", "program", "executableUnit", "mainProgram",
"functionSubprogram", "subroutineSubprogram", "blockdataSubprogram",
"otherSpecificationStatement", "executableStatement",
"programStatement", "entryStatement", "functionStatement",
"blockdataStatement", "subroutineStatement", "namelist",
"statement", "subprogramBody", "wholeStatement", "endStatement",
"dimensionStatement", "arrayDeclarator", "arrayDeclarators",
"arrayDeclaratorExtents", "arrayDeclaratorExtent", "equivalenceStatement",
"equivEntityGroup", "equivEntity", "commonStatement",
"commonName", "commonItem", "commonItems", "commonBlock",
"typeStatement", "typeStatementNameList", "typeStatementName",
"typeStatementNameCharList", "typeStatementNameChar",
"typeStatementLenSpec", "typename_", "type_", "typenameLen",
"pointerStatement", "pointerDecl", "implicitStatement",
"implicitSpec", "implicitSpecs", "implicitNone", "implicitLetter",
"implicitRange", "implicitLetters", "lenSpecification",
"characterWithLen", "cwlLen", "parameterStatement", "paramlist",
"paramassign", "externalStatement", "intrinsicStatement",
"saveStatement", "saveEntity", "dataStatement", "dataStatementItem",
"dataStatementMultiple", "dataStatementEntity", "dse1",
"dse2", "dataImpliedDo", "dataImpliedDoRange", "dataImpliedDoList",
"dataImpliedDoListWhat", "gotoStatement", "unconditionalGoto",
"computedGoto", "lblRef", "labelList", "assignedGoto",
"ifStatement", "arithmeticIfStatement", "logicalIfStatement",
"blockIfStatement", "firstIfBlock", "elseIfStatement",
"elseStatement", "endIfStatement", "doStatement", "doVarArgs",
"doWithLabel", "doBody", "doWithEndDo", "enddoStatement",
"continueStatement", "stopStatement", "pauseStatement",
"writeStatement", "readStatement", "printStatement",
"assignmentStatement", "controlInfoList", "controlErrSpec",
"controlInfoListItem", "ioList", "ioListItem", "ioImpliedDoList",
"openStatement", "openControl", "controlFmt", "controlUnit",
"controlRec", "controlEnd", "controlErr", "controlIostat",
"controlFile", "controlStatus", "controlAccess", "controlPosition",
"controlForm", "controlRecl", "controlBlank", "controlExist",
"controlOpened", "controlNumber", "controlNamed", "controlName",
"controlSequential", "controlDirect", "controlFormatted",
"controlUnformatted", "controlNextrec", "closeStatement",
"closeControl", "inquireStatement", "inquireControl",
"backspaceStatement", "endfileStatement", "rewindStatement",
"berFinish", "berFinishItem", "unitIdentifier", "formatIdentifier",
"formatStatement", "fmtSpec", "formatsep", "formatedit",
"editElement", "statementFunctionStatement", "sfArgs",
"callStatement", "subroutineCall", "callArgumentList",
"callArgument", "returnStatement", "expression", "ncExpr",
"lexpr0", "lexpr1", "lexpr2", "lexpr3", "lexpr4", "aexpr0",
"aexpr1", "aexpr2", "aexpr3", "aexpr4", "iexpr", "iexprCode",
"iexpr1", "iexpr2", "iexpr3", "iexpr4", "constantExpr",
"arithmeticExpression", "integerExpr", "intRealDpExpr",
"arithmeticConstExpr", "intConstantExpr", "characterExpression",
"concatOp", "logicalExpression", "logicalConstExpr",
"arrayElementName", "subscripts", "varRef", "varRefCode",
"substringApp", "variableName", "arrayName", "subroutineName",
"functionName", "constant", "unsignedArithmeticConstant",
"complexConstant", "logicalConstant", "identifier", "to" ]
EOF = Token.EOF
PROGRAM=1
ENTRY=2
FUNCTION=3
BLOCK=4
SUBROUTINE=5
END=6
DIMENSION=7
REAL=8
EQUIVALENCE=9
COMMON=10
POINTER=11
IMPLICIT=12
NONE=13
CHARACTER=14
PARAMETER=15
EXTERNAL=16
INTRINSIC=17
SAVE=18
DATA=19
GO=20
GOTO=21
IF=22
THEN=23
ELSE=24
ENDIF=25
ELSEIF=26
DO=27
CONTINUE=28
STOP=29
ENDDO=30
PAUSE=31
WRITE=32
READ=33
PRINT=34
OPEN=35
FMT=36
UNIT=37
ERR=38
IOSTAT=39
FORMAT=40
LET=41
CALL=42
RETURN=43
CLOSE=44
DOUBLE=45
IOSTART=46
SEQUENTIAL=47
LABEL=48
FILE=49
STATUS=50
ACCESS=51
POSITION=52
FORM=53
RECL=54
BLANK=55
EXIST=56
OPENED=57
NUMBER=58
NAMED=59
NAME_=60
FORMATTED=61
UNFORMATTED=62
NEXTREC=63
INQUIRE=64
BACKSPACE=65
ENDFILE=66
REWIND=67
DOLLAR=68
COMMA=69
LPAREN=70
RPAREN=71
COLON=72
ASSIGN=73
MINUS=74
PLUS=75
DIV=76
POWER=77
LNOT=78
LAND=79
LOR=80
EQV=81
NEQV=82
XOR=83
EOR=84
LT=85
LE=86
GT=87
GE=88
NE=89
EQ=90
TRUE=91
FALSE=92
XCON=93
PCON=94
FCON=95
CCON=96
HOLLERITH=97
CONCATOP=98
CTRLDIRECT=99
CTRLREC=100
TO=101
SUBPROGRAMBLOCK=102
DOBLOCK=103
AIF=104
THENBLOCK=105
ELSEBLOCK=106
CODEROOT=107
COMPLEX=108
PRECISION=109
INTEGER=110
LOGICAL=111
SCON=112
RCON=113
ICON=114
NAME=115
COMMENT=116
STAR=117
STRINGLITERAL=118
EOL=119
LINECONT=120
WS=121
def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
super().__init__(input, output)
self.checkVersion("4.8")
self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
self._predicates = None
[docs]
class ProgramContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def executableUnit(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.ExecutableUnitContext)
else:
return self.getTypedRuleContext(Fortran77Parser.ExecutableUnitContext,i)
[docs]
def EOL(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.EOL)
else:
return self.getToken(Fortran77Parser.EOL, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_program
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterProgram" ):
listener.enterProgram(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitProgram" ):
listener.exitProgram(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitProgram" ):
return visitor.visitProgram(self)
else:
return visitor.visitChildren(self)
[docs]
def program(self):
localctx = Fortran77Parser.ProgramContext(self, self._ctx, self.state)
self.enterRule(localctx, 2, self.RULE_program)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 396
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,1,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 393
self.commentStatement()
self.state = 398
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,1,self._ctx)
self.state = 406
self._errHandler.sync(self)
_la = self._input.LA(1)
while True:
self.state = 399
self.executableUnit()
self.state = 403
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,2,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 400
self.commentStatement()
self.state = 405
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,2,self._ctx)
self.state = 408
self._errHandler.sync(self)
_la = self._input.LA(1)
if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Fortran77Parser.PROGRAM) | (1 << Fortran77Parser.ENTRY) | (1 << Fortran77Parser.FUNCTION) | (1 << Fortran77Parser.BLOCK) | (1 << Fortran77Parser.SUBROUTINE) | (1 << Fortran77Parser.DIMENSION) | (1 << Fortran77Parser.REAL) | (1 << Fortran77Parser.EQUIVALENCE) | (1 << Fortran77Parser.COMMON) | (1 << Fortran77Parser.POINTER) | (1 << Fortran77Parser.IMPLICIT) | (1 << Fortran77Parser.CHARACTER) | (1 << Fortran77Parser.PARAMETER) | (1 << Fortran77Parser.EXTERNAL) | (1 << Fortran77Parser.INTRINSIC) | (1 << Fortran77Parser.SAVE) | (1 << Fortran77Parser.DATA) | (1 << Fortran77Parser.GO) | (1 << Fortran77Parser.GOTO) | (1 << Fortran77Parser.IF) | (1 << Fortran77Parser.DO) | (1 << Fortran77Parser.CONTINUE) | (1 << Fortran77Parser.STOP) | (1 << Fortran77Parser.PAUSE) | (1 << Fortran77Parser.WRITE) | (1 << Fortran77Parser.READ) | (1 << Fortran77Parser.PRINT) | (1 << Fortran77Parser.OPEN) | (1 << Fortran77Parser.LET) | (1 << Fortran77Parser.CALL) | (1 << Fortran77Parser.RETURN) | (1 << Fortran77Parser.CLOSE) | (1 << Fortran77Parser.DOUBLE) | (1 << Fortran77Parser.LABEL))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (Fortran77Parser.INQUIRE - 64)) | (1 << (Fortran77Parser.BACKSPACE - 64)) | (1 << (Fortran77Parser.ENDFILE - 64)) | (1 << (Fortran77Parser.REWIND - 64)) | (1 << (Fortran77Parser.LPAREN - 64)) | (1 << (Fortran77Parser.MINUS - 64)) | (1 << (Fortran77Parser.PLUS - 64)) | (1 << (Fortran77Parser.LNOT - 64)) | (1 << (Fortran77Parser.TRUE - 64)) | (1 << (Fortran77Parser.FALSE - 64)) | (1 << (Fortran77Parser.HOLLERITH - 64)) | (1 << (Fortran77Parser.COMPLEX - 64)) | (1 << (Fortran77Parser.INTEGER - 64)) | (1 << (Fortran77Parser.LOGICAL - 64)) | (1 << (Fortran77Parser.SCON - 64)) | (1 << (Fortran77Parser.RCON - 64)) | (1 << (Fortran77Parser.ICON - 64)) | (1 << (Fortran77Parser.NAME - 64)) | (1 << (Fortran77Parser.COMMENT - 64)))) != 0)):
break
self.state = 413
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.EOL:
self.state = 410
self.match(Fortran77Parser.EOL)
self.state = 415
self._errHandler.sync(self)
_la = self._input.LA(1)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ExecutableUnitContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def functionSubprogram(self):
return self.getTypedRuleContext(Fortran77Parser.FunctionSubprogramContext,0)
[docs]
def mainProgram(self):
return self.getTypedRuleContext(Fortran77Parser.MainProgramContext,0)
[docs]
def subroutineSubprogram(self):
return self.getTypedRuleContext(Fortran77Parser.SubroutineSubprogramContext,0)
[docs]
def blockdataSubprogram(self):
return self.getTypedRuleContext(Fortran77Parser.BlockdataSubprogramContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_executableUnit
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterExecutableUnit" ):
listener.enterExecutableUnit(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitExecutableUnit" ):
listener.exitExecutableUnit(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitExecutableUnit" ):
return visitor.visitExecutableUnit(self)
else:
return visitor.visitChildren(self)
[docs]
def executableUnit(self):
localctx = Fortran77Parser.ExecutableUnitContext(self, self._ctx, self.state)
self.enterRule(localctx, 4, self.RULE_executableUnit)
try:
self.state = 420
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,5,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 416
self.functionSubprogram()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 417
self.mainProgram()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 418
self.subroutineSubprogram()
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 419
self.blockdataSubprogram()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class MainProgramContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def subprogramBody(self):
return self.getTypedRuleContext(Fortran77Parser.SubprogramBodyContext,0)
[docs]
def programStatement(self):
return self.getTypedRuleContext(Fortran77Parser.ProgramStatementContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_mainProgram
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterMainProgram" ):
listener.enterMainProgram(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitMainProgram" ):
listener.exitMainProgram(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitMainProgram" ):
return visitor.visitMainProgram(self)
else:
return visitor.visitChildren(self)
[docs]
def mainProgram(self):
localctx = Fortran77Parser.MainProgramContext(self, self._ctx, self.state)
self.enterRule(localctx, 6, self.RULE_mainProgram)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 423
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.PROGRAM:
self.state = 422
self.programStatement()
self.state = 425
self.subprogramBody()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class FunctionSubprogramContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def functionStatement(self):
return self.getTypedRuleContext(Fortran77Parser.FunctionStatementContext,0)
[docs]
def subprogramBody(self):
return self.getTypedRuleContext(Fortran77Parser.SubprogramBodyContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_functionSubprogram
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterFunctionSubprogram" ):
listener.enterFunctionSubprogram(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitFunctionSubprogram" ):
listener.exitFunctionSubprogram(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFunctionSubprogram" ):
return visitor.visitFunctionSubprogram(self)
else:
return visitor.visitChildren(self)
[docs]
def functionSubprogram(self):
localctx = Fortran77Parser.FunctionSubprogramContext(self, self._ctx, self.state)
self.enterRule(localctx, 8, self.RULE_functionSubprogram)
try:
self.enterOuterAlt(localctx, 1)
self.state = 427
self.functionStatement()
self.state = 428
self.subprogramBody()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class SubroutineSubprogramContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def subroutineStatement(self):
return self.getTypedRuleContext(Fortran77Parser.SubroutineStatementContext,0)
[docs]
def subprogramBody(self):
return self.getTypedRuleContext(Fortran77Parser.SubprogramBodyContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_subroutineSubprogram
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSubroutineSubprogram" ):
listener.enterSubroutineSubprogram(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSubroutineSubprogram" ):
listener.exitSubroutineSubprogram(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSubroutineSubprogram" ):
return visitor.visitSubroutineSubprogram(self)
else:
return visitor.visitChildren(self)
[docs]
def subroutineSubprogram(self):
localctx = Fortran77Parser.SubroutineSubprogramContext(self, self._ctx, self.state)
self.enterRule(localctx, 10, self.RULE_subroutineSubprogram)
try:
self.enterOuterAlt(localctx, 1)
self.state = 430
self.subroutineStatement()
self.state = 431
self.subprogramBody()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class BlockdataSubprogramContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def blockdataStatement(self):
return self.getTypedRuleContext(Fortran77Parser.BlockdataStatementContext,0)
[docs]
def subprogramBody(self):
return self.getTypedRuleContext(Fortran77Parser.SubprogramBodyContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_blockdataSubprogram
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterBlockdataSubprogram" ):
listener.enterBlockdataSubprogram(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitBlockdataSubprogram" ):
listener.exitBlockdataSubprogram(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitBlockdataSubprogram" ):
return visitor.visitBlockdataSubprogram(self)
else:
return visitor.visitChildren(self)
[docs]
def blockdataSubprogram(self):
localctx = Fortran77Parser.BlockdataSubprogramContext(self, self._ctx, self.state)
self.enterRule(localctx, 12, self.RULE_blockdataSubprogram)
try:
self.enterOuterAlt(localctx, 1)
self.state = 433
self.blockdataStatement()
self.state = 434
self.subprogramBody()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class OtherSpecificationStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def dimensionStatement(self):
return self.getTypedRuleContext(Fortran77Parser.DimensionStatementContext,0)
[docs]
def equivalenceStatement(self):
return self.getTypedRuleContext(Fortran77Parser.EquivalenceStatementContext,0)
[docs]
def intrinsicStatement(self):
return self.getTypedRuleContext(Fortran77Parser.IntrinsicStatementContext,0)
[docs]
def saveStatement(self):
return self.getTypedRuleContext(Fortran77Parser.SaveStatementContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_otherSpecificationStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterOtherSpecificationStatement" ):
listener.enterOtherSpecificationStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitOtherSpecificationStatement" ):
listener.exitOtherSpecificationStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitOtherSpecificationStatement" ):
return visitor.visitOtherSpecificationStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def otherSpecificationStatement(self):
localctx = Fortran77Parser.OtherSpecificationStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 14, self.RULE_otherSpecificationStatement)
try:
self.state = 440
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran77Parser.DIMENSION]:
self.enterOuterAlt(localctx, 1)
self.state = 436
self.dimensionStatement()
pass
elif token in [Fortran77Parser.EQUIVALENCE]:
self.enterOuterAlt(localctx, 2)
self.state = 437
self.equivalenceStatement()
pass
elif token in [Fortran77Parser.INTRINSIC]:
self.enterOuterAlt(localctx, 3)
self.state = 438
self.intrinsicStatement()
pass
elif token in [Fortran77Parser.SAVE]:
self.enterOuterAlt(localctx, 4)
self.state = 439
self.saveStatement()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ExecutableStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def assignmentStatement(self):
return self.getTypedRuleContext(Fortran77Parser.AssignmentStatementContext,0)
[docs]
def gotoStatement(self):
return self.getTypedRuleContext(Fortran77Parser.GotoStatementContext,0)
[docs]
def ifStatement(self):
return self.getTypedRuleContext(Fortran77Parser.IfStatementContext,0)
[docs]
def doStatement(self):
return self.getTypedRuleContext(Fortran77Parser.DoStatementContext,0)
[docs]
def continueStatement(self):
return self.getTypedRuleContext(Fortran77Parser.ContinueStatementContext,0)
[docs]
def stopStatement(self):
return self.getTypedRuleContext(Fortran77Parser.StopStatementContext,0)
[docs]
def pauseStatement(self):
return self.getTypedRuleContext(Fortran77Parser.PauseStatementContext,0)
[docs]
def readStatement(self):
return self.getTypedRuleContext(Fortran77Parser.ReadStatementContext,0)
[docs]
def writeStatement(self):
return self.getTypedRuleContext(Fortran77Parser.WriteStatementContext,0)
[docs]
def printStatement(self):
return self.getTypedRuleContext(Fortran77Parser.PrintStatementContext,0)
[docs]
def rewindStatement(self):
return self.getTypedRuleContext(Fortran77Parser.RewindStatementContext,0)
[docs]
def backspaceStatement(self):
return self.getTypedRuleContext(Fortran77Parser.BackspaceStatementContext,0)
[docs]
def openStatement(self):
return self.getTypedRuleContext(Fortran77Parser.OpenStatementContext,0)
[docs]
def closeStatement(self):
return self.getTypedRuleContext(Fortran77Parser.CloseStatementContext,0)
[docs]
def endfileStatement(self):
return self.getTypedRuleContext(Fortran77Parser.EndfileStatementContext,0)
[docs]
def inquireStatement(self):
return self.getTypedRuleContext(Fortran77Parser.InquireStatementContext,0)
[docs]
def callStatement(self):
return self.getTypedRuleContext(Fortran77Parser.CallStatementContext,0)
[docs]
def returnStatement(self):
return self.getTypedRuleContext(Fortran77Parser.ReturnStatementContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_executableStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterExecutableStatement" ):
listener.enterExecutableStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitExecutableStatement" ):
listener.exitExecutableStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitExecutableStatement" ):
return visitor.visitExecutableStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def executableStatement(self):
localctx = Fortran77Parser.ExecutableStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 16, self.RULE_executableStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 460
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran77Parser.REAL, Fortran77Parser.NAME]:
self.state = 442
self.assignmentStatement()
pass
elif token in [Fortran77Parser.GO, Fortran77Parser.GOTO]:
self.state = 443
self.gotoStatement()
pass
elif token in [Fortran77Parser.IF]:
self.state = 444
self.ifStatement()
pass
elif token in [Fortran77Parser.DO]:
self.state = 445
self.doStatement()
pass
elif token in [Fortran77Parser.CONTINUE, Fortran77Parser.ICON]:
self.state = 446
self.continueStatement()
pass
elif token in [Fortran77Parser.STOP]:
self.state = 447
self.stopStatement()
pass
elif token in [Fortran77Parser.PAUSE]:
self.state = 448
self.pauseStatement()
pass
elif token in [Fortran77Parser.READ]:
self.state = 449
self.readStatement()
pass
elif token in [Fortran77Parser.WRITE]:
self.state = 450
self.writeStatement()
pass
elif token in [Fortran77Parser.PRINT]:
self.state = 451
self.printStatement()
pass
elif token in [Fortran77Parser.REWIND]:
self.state = 452
self.rewindStatement()
pass
elif token in [Fortran77Parser.BACKSPACE]:
self.state = 453
self.backspaceStatement()
pass
elif token in [Fortran77Parser.OPEN]:
self.state = 454
self.openStatement()
pass
elif token in [Fortran77Parser.CLOSE]:
self.state = 455
self.closeStatement()
pass
elif token in [Fortran77Parser.ENDFILE]:
self.state = 456
self.endfileStatement()
pass
elif token in [Fortran77Parser.INQUIRE]:
self.state = 457
self.inquireStatement()
pass
elif token in [Fortran77Parser.CALL]:
self.state = 458
self.callStatement()
pass
elif token in [Fortran77Parser.RETURN]:
self.state = 459
self.returnStatement()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ProgramStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def PROGRAM(self):
return self.getToken(Fortran77Parser.PROGRAM, 0)
[docs]
def NAME(self):
return self.getToken(Fortran77Parser.NAME, 0)
[docs]
def EOL(self):
return self.getToken(Fortran77Parser.EOL, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_programStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterProgramStatement" ):
listener.enterProgramStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitProgramStatement" ):
listener.exitProgramStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitProgramStatement" ):
return visitor.visitProgramStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def programStatement(self):
localctx = Fortran77Parser.ProgramStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 18, self.RULE_programStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 462
self.match(Fortran77Parser.PROGRAM)
self.state = 463
self.match(Fortran77Parser.NAME)
self.state = 464
self.match(Fortran77Parser.EOL)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class EntryStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ENTRY(self):
return self.getToken(Fortran77Parser.ENTRY, 0)
[docs]
def NAME(self):
return self.getToken(Fortran77Parser.NAME, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran77Parser.LPAREN, 0)
[docs]
def namelist(self):
return self.getTypedRuleContext(Fortran77Parser.NamelistContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran77Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_entryStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEntryStatement" ):
listener.enterEntryStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEntryStatement" ):
listener.exitEntryStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEntryStatement" ):
return visitor.visitEntryStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def entryStatement(self):
localctx = Fortran77Parser.EntryStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 20, self.RULE_entryStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 466
self.match(Fortran77Parser.ENTRY)
self.state = 467
self.match(Fortran77Parser.NAME)
self.state = 472
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.LPAREN:
self.state = 468
self.match(Fortran77Parser.LPAREN)
self.state = 469
self.namelist()
self.state = 470
self.match(Fortran77Parser.RPAREN)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class FunctionStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def FUNCTION(self):
return self.getToken(Fortran77Parser.FUNCTION, 0)
[docs]
def NAME(self):
return self.getToken(Fortran77Parser.NAME, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran77Parser.LPAREN, 0)
[docs]
def RPAREN(self):
return self.getToken(Fortran77Parser.RPAREN, 0)
[docs]
def type_(self):
return self.getTypedRuleContext(Fortran77Parser.Type_Context,0)
[docs]
def namelist(self):
return self.getTypedRuleContext(Fortran77Parser.NamelistContext,0)
[docs]
def EOL(self):
return self.getToken(Fortran77Parser.EOL, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_functionStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterFunctionStatement" ):
listener.enterFunctionStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitFunctionStatement" ):
listener.exitFunctionStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFunctionStatement" ):
return visitor.visitFunctionStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def functionStatement(self):
localctx = Fortran77Parser.FunctionStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 22, self.RULE_functionStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 475
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Fortran77Parser.REAL) | (1 << Fortran77Parser.CHARACTER) | (1 << Fortran77Parser.DOUBLE))) != 0) or ((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & ((1 << (Fortran77Parser.LPAREN - 70)) | (1 << (Fortran77Parser.MINUS - 70)) | (1 << (Fortran77Parser.PLUS - 70)) | (1 << (Fortran77Parser.LNOT - 70)) | (1 << (Fortran77Parser.TRUE - 70)) | (1 << (Fortran77Parser.FALSE - 70)) | (1 << (Fortran77Parser.HOLLERITH - 70)) | (1 << (Fortran77Parser.COMPLEX - 70)) | (1 << (Fortran77Parser.INTEGER - 70)) | (1 << (Fortran77Parser.LOGICAL - 70)) | (1 << (Fortran77Parser.SCON - 70)) | (1 << (Fortran77Parser.RCON - 70)) | (1 << (Fortran77Parser.ICON - 70)) | (1 << (Fortran77Parser.NAME - 70)))) != 0):
self.state = 474
self.type_()
self.state = 477
self.match(Fortran77Parser.FUNCTION)
self.state = 478
self.match(Fortran77Parser.NAME)
self.state = 479
self.match(Fortran77Parser.LPAREN)
self.state = 481
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.REAL or _la==Fortran77Parser.NAME:
self.state = 480
self.namelist()
self.state = 483
self.match(Fortran77Parser.RPAREN)
self.state = 485
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.EOL:
self.state = 484
self.match(Fortran77Parser.EOL)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class BlockdataStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def BLOCK(self):
return self.getToken(Fortran77Parser.BLOCK, 0)
[docs]
def NAME(self):
return self.getToken(Fortran77Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_blockdataStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterBlockdataStatement" ):
listener.enterBlockdataStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitBlockdataStatement" ):
listener.exitBlockdataStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitBlockdataStatement" ):
return visitor.visitBlockdataStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def blockdataStatement(self):
localctx = Fortran77Parser.BlockdataStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 24, self.RULE_blockdataStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 487
self.match(Fortran77Parser.BLOCK)
self.state = 488
self.match(Fortran77Parser.NAME)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class SubroutineStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def SUBROUTINE(self):
return self.getToken(Fortran77Parser.SUBROUTINE, 0)
[docs]
def NAME(self):
return self.getToken(Fortran77Parser.NAME, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran77Parser.LPAREN, 0)
[docs]
def RPAREN(self):
return self.getToken(Fortran77Parser.RPAREN, 0)
[docs]
def EOL(self):
return self.getToken(Fortran77Parser.EOL, 0)
[docs]
def namelist(self):
return self.getTypedRuleContext(Fortran77Parser.NamelistContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_subroutineStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSubroutineStatement" ):
listener.enterSubroutineStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSubroutineStatement" ):
listener.exitSubroutineStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSubroutineStatement" ):
return visitor.visitSubroutineStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def subroutineStatement(self):
localctx = Fortran77Parser.SubroutineStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 26, self.RULE_subroutineStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 490
self.match(Fortran77Parser.SUBROUTINE)
self.state = 491
self.match(Fortran77Parser.NAME)
self.state = 497
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,14,self._ctx)
if la_ == 1:
self.state = 492
self.match(Fortran77Parser.LPAREN)
self.state = 494
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.REAL or _la==Fortran77Parser.NAME:
self.state = 493
self.namelist()
self.state = 496
self.match(Fortran77Parser.RPAREN)
self.state = 500
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.EOL:
self.state = 499
self.match(Fortran77Parser.EOL)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class NamelistContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def identifier(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.IdentifierContext)
else:
return self.getTypedRuleContext(Fortran77Parser.IdentifierContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.COMMA)
else:
return self.getToken(Fortran77Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_namelist
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterNamelist" ):
listener.enterNamelist(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitNamelist" ):
listener.exitNamelist(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNamelist" ):
return visitor.visitNamelist(self)
else:
return visitor.visitChildren(self)
[docs]
def namelist(self):
localctx = Fortran77Parser.NamelistContext(self, self._ctx, self.state)
self.enterRule(localctx, 28, self.RULE_namelist)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 502
self.identifier()
self.state = 507
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.COMMA:
self.state = 503
self.match(Fortran77Parser.COMMA)
self.state = 504
self.identifier()
self.state = 509
self._errHandler.sync(self)
_la = self._input.LA(1)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class StatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def entryStatement(self):
return self.getTypedRuleContext(Fortran77Parser.EntryStatementContext,0)
[docs]
def implicitStatement(self):
return self.getTypedRuleContext(Fortran77Parser.ImplicitStatementContext,0)
[docs]
def parameterStatement(self):
return self.getTypedRuleContext(Fortran77Parser.ParameterStatementContext,0)
[docs]
def typeStatement(self):
return self.getTypedRuleContext(Fortran77Parser.TypeStatementContext,0)
[docs]
def commonStatement(self):
return self.getTypedRuleContext(Fortran77Parser.CommonStatementContext,0)
[docs]
def pointerStatement(self):
return self.getTypedRuleContext(Fortran77Parser.PointerStatementContext,0)
[docs]
def externalStatement(self):
return self.getTypedRuleContext(Fortran77Parser.ExternalStatementContext,0)
[docs]
def otherSpecificationStatement(self):
return self.getTypedRuleContext(Fortran77Parser.OtherSpecificationStatementContext,0)
[docs]
def dataStatement(self):
return self.getTypedRuleContext(Fortran77Parser.DataStatementContext,0)
[docs]
def statementFunctionStatement(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.StatementFunctionStatementContext)
else:
return self.getTypedRuleContext(Fortran77Parser.StatementFunctionStatementContext,i)
[docs]
def executableStatement(self):
return self.getTypedRuleContext(Fortran77Parser.ExecutableStatementContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_statement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterStatement" ):
listener.enterStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitStatement" ):
listener.exitStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitStatement" ):
return visitor.visitStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def statement(self):
localctx = Fortran77Parser.StatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 30, self.RULE_statement)
try:
self.state = 523
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,17,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 510
self.entryStatement()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 511
self.implicitStatement()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 512
self.parameterStatement()
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 513
self.typeStatement()
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 514
self.commonStatement()
pass
elif la_ == 6:
self.enterOuterAlt(localctx, 6)
self.state = 515
self.pointerStatement()
pass
elif la_ == 7:
self.enterOuterAlt(localctx, 7)
self.state = 516
self.externalStatement()
pass
elif la_ == 8:
self.enterOuterAlt(localctx, 8)
self.state = 517
self.otherSpecificationStatement()
pass
elif la_ == 9:
self.enterOuterAlt(localctx, 9)
self.state = 518
self.dataStatement()
pass
elif la_ == 10:
self.enterOuterAlt(localctx, 10)
self.state = 519
self.statementFunctionStatement()
self.state = 520
self.statementFunctionStatement()
pass
elif la_ == 11:
self.enterOuterAlt(localctx, 11)
self.state = 522
self.executableStatement()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class SubprogramBodyContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def endStatement(self):
return self.getTypedRuleContext(Fortran77Parser.EndStatementContext,0)
[docs]
def commentStatement(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.CommentStatementContext)
else:
return self.getTypedRuleContext(Fortran77Parser.CommentStatementContext,i)
[docs]
def wholeStatement(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.WholeStatementContext)
else:
return self.getTypedRuleContext(Fortran77Parser.WholeStatementContext,i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_subprogramBody
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSubprogramBody" ):
listener.enterSubprogramBody(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSubprogramBody" ):
listener.exitSubprogramBody(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSubprogramBody" ):
return visitor.visitSubprogramBody(self)
else:
return visitor.visitChildren(self)
[docs]
def subprogramBody(self):
localctx = Fortran77Parser.SubprogramBodyContext(self, self._ctx, self.state)
self.enterRule(localctx, 32, self.RULE_subprogramBody)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 528
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.COMMENT:
self.state = 525
self.commentStatement()
self.state = 530
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 538
self._errHandler.sync(self)
_alt = 1
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 531
self.wholeStatement()
self.state = 535
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.COMMENT:
self.state = 532
self.commentStatement()
self.state = 537
self._errHandler.sync(self)
_la = self._input.LA(1)
else:
raise NoViableAltException(self)
self.state = 540
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,20,self._ctx)
self.state = 542
self.endStatement()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class WholeStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def statement(self):
return self.getTypedRuleContext(Fortran77Parser.StatementContext,0)
[docs]
def EOL(self):
return self.getToken(Fortran77Parser.EOL, 0)
[docs]
def LABEL(self):
return self.getToken(Fortran77Parser.LABEL, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_wholeStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterWholeStatement" ):
listener.enterWholeStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitWholeStatement" ):
listener.exitWholeStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitWholeStatement" ):
return visitor.visitWholeStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def wholeStatement(self):
localctx = Fortran77Parser.WholeStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 34, self.RULE_wholeStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 545
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.LABEL:
self.state = 544
self.match(Fortran77Parser.LABEL)
self.state = 547
self.statement()
self.state = 548
self.match(Fortran77Parser.EOL)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class EndStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def END(self):
return self.getToken(Fortran77Parser.END, 0)
[docs]
def LABEL(self):
return self.getToken(Fortran77Parser.LABEL, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_endStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEndStatement" ):
listener.enterEndStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEndStatement" ):
listener.exitEndStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEndStatement" ):
return visitor.visitEndStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def endStatement(self):
localctx = Fortran77Parser.EndStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 36, self.RULE_endStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 551
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.LABEL:
self.state = 550
self.match(Fortran77Parser.LABEL)
self.state = 553
self.match(Fortran77Parser.END)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class DimensionStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def DIMENSION(self):
return self.getToken(Fortran77Parser.DIMENSION, 0)
[docs]
def arrayDeclarators(self):
return self.getTypedRuleContext(Fortran77Parser.ArrayDeclaratorsContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_dimensionStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDimensionStatement" ):
listener.enterDimensionStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDimensionStatement" ):
listener.exitDimensionStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDimensionStatement" ):
return visitor.visitDimensionStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def dimensionStatement(self):
localctx = Fortran77Parser.DimensionStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 38, self.RULE_dimensionStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 555
self.match(Fortran77Parser.DIMENSION)
self.state = 556
self.arrayDeclarators()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ArrayDeclaratorContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def LPAREN(self):
return self.getToken(Fortran77Parser.LPAREN, 0)
[docs]
def arrayDeclaratorExtents(self):
return self.getTypedRuleContext(Fortran77Parser.ArrayDeclaratorExtentsContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran77Parser.RPAREN, 0)
[docs]
def NAME(self):
return self.getToken(Fortran77Parser.NAME, 0)
[docs]
def REAL(self):
return self.getToken(Fortran77Parser.REAL, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_arrayDeclarator
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterArrayDeclarator" ):
listener.enterArrayDeclarator(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitArrayDeclarator" ):
listener.exitArrayDeclarator(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitArrayDeclarator" ):
return visitor.visitArrayDeclarator(self)
else:
return visitor.visitChildren(self)
[docs]
def arrayDeclarator(self):
localctx = Fortran77Parser.ArrayDeclaratorContext(self, self._ctx, self.state)
self.enterRule(localctx, 40, self.RULE_arrayDeclarator)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 558
_la = self._input.LA(1)
if not(_la==Fortran77Parser.REAL or _la==Fortran77Parser.NAME):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 559
self.match(Fortran77Parser.LPAREN)
self.state = 560
self.arrayDeclaratorExtents()
self.state = 561
self.match(Fortran77Parser.RPAREN)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ArrayDeclaratorsContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def arrayDeclarator(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.ArrayDeclaratorContext)
else:
return self.getTypedRuleContext(Fortran77Parser.ArrayDeclaratorContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.COMMA)
else:
return self.getToken(Fortran77Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_arrayDeclarators
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterArrayDeclarators" ):
listener.enterArrayDeclarators(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitArrayDeclarators" ):
listener.exitArrayDeclarators(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitArrayDeclarators" ):
return visitor.visitArrayDeclarators(self)
else:
return visitor.visitChildren(self)
[docs]
def arrayDeclarators(self):
localctx = Fortran77Parser.ArrayDeclaratorsContext(self, self._ctx, self.state)
self.enterRule(localctx, 42, self.RULE_arrayDeclarators)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 563
self.arrayDeclarator()
self.state = 568
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.COMMA:
self.state = 564
self.match(Fortran77Parser.COMMA)
self.state = 565
self.arrayDeclarator()
self.state = 570
self._errHandler.sync(self)
_la = self._input.LA(1)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ArrayDeclaratorExtentsContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def arrayDeclaratorExtent(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.ArrayDeclaratorExtentContext)
else:
return self.getTypedRuleContext(Fortran77Parser.ArrayDeclaratorExtentContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.COMMA)
else:
return self.getToken(Fortran77Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_arrayDeclaratorExtents
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterArrayDeclaratorExtents" ):
listener.enterArrayDeclaratorExtents(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitArrayDeclaratorExtents" ):
listener.exitArrayDeclaratorExtents(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitArrayDeclaratorExtents" ):
return visitor.visitArrayDeclaratorExtents(self)
else:
return visitor.visitChildren(self)
[docs]
def arrayDeclaratorExtents(self):
localctx = Fortran77Parser.ArrayDeclaratorExtentsContext(self, self._ctx, self.state)
self.enterRule(localctx, 44, self.RULE_arrayDeclaratorExtents)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 571
self.arrayDeclaratorExtent()
self.state = 576
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.COMMA:
self.state = 572
self.match(Fortran77Parser.COMMA)
self.state = 573
self.arrayDeclaratorExtent()
self.state = 578
self._errHandler.sync(self)
_la = self._input.LA(1)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ArrayDeclaratorExtentContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def iexprCode(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.IexprCodeContext)
else:
return self.getTypedRuleContext(Fortran77Parser.IexprCodeContext,i)
[docs]
def COLON(self):
return self.getToken(Fortran77Parser.COLON, 0)
[docs]
def STAR(self):
return self.getToken(Fortran77Parser.STAR, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_arrayDeclaratorExtent
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterArrayDeclaratorExtent" ):
listener.enterArrayDeclaratorExtent(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitArrayDeclaratorExtent" ):
listener.exitArrayDeclaratorExtent(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitArrayDeclaratorExtent" ):
return visitor.visitArrayDeclaratorExtent(self)
else:
return visitor.visitChildren(self)
[docs]
def arrayDeclaratorExtent(self):
localctx = Fortran77Parser.ArrayDeclaratorExtentContext(self, self._ctx, self.state)
self.enterRule(localctx, 46, self.RULE_arrayDeclaratorExtent)
self._la = 0 # Token type
try:
self.state = 588
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran77Parser.LPAREN, Fortran77Parser.MINUS, Fortran77Parser.PLUS, Fortran77Parser.ICON, Fortran77Parser.NAME]:
self.enterOuterAlt(localctx, 1)
self.state = 579
self.iexprCode()
self.state = 585
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.COLON:
self.state = 580
self.match(Fortran77Parser.COLON)
self.state = 583
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran77Parser.LPAREN, Fortran77Parser.MINUS, Fortran77Parser.PLUS, Fortran77Parser.ICON, Fortran77Parser.NAME]:
self.state = 581
self.iexprCode()
pass
elif token in [Fortran77Parser.STAR]:
self.state = 582
self.match(Fortran77Parser.STAR)
pass
else:
raise NoViableAltException(self)
pass
elif token in [Fortran77Parser.STAR]:
self.enterOuterAlt(localctx, 2)
self.state = 587
self.match(Fortran77Parser.STAR)
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class EquivalenceStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def EQUIVALENCE(self):
return self.getToken(Fortran77Parser.EQUIVALENCE, 0)
[docs]
def equivEntityGroup(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.EquivEntityGroupContext)
else:
return self.getTypedRuleContext(Fortran77Parser.EquivEntityGroupContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.COMMA)
else:
return self.getToken(Fortran77Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_equivalenceStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEquivalenceStatement" ):
listener.enterEquivalenceStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEquivalenceStatement" ):
listener.exitEquivalenceStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEquivalenceStatement" ):
return visitor.visitEquivalenceStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def equivalenceStatement(self):
localctx = Fortran77Parser.EquivalenceStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 48, self.RULE_equivalenceStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 590
self.match(Fortran77Parser.EQUIVALENCE)
self.state = 591
self.equivEntityGroup()
self.state = 596
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.COMMA:
self.state = 592
self.match(Fortran77Parser.COMMA)
self.state = 593
self.equivEntityGroup()
self.state = 598
self._errHandler.sync(self)
_la = self._input.LA(1)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class EquivEntityGroupContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def LPAREN(self):
return self.getToken(Fortran77Parser.LPAREN, 0)
[docs]
def equivEntity(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.EquivEntityContext)
else:
return self.getTypedRuleContext(Fortran77Parser.EquivEntityContext,i)
[docs]
def RPAREN(self):
return self.getToken(Fortran77Parser.RPAREN, 0)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.COMMA)
else:
return self.getToken(Fortran77Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_equivEntityGroup
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEquivEntityGroup" ):
listener.enterEquivEntityGroup(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEquivEntityGroup" ):
listener.exitEquivEntityGroup(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEquivEntityGroup" ):
return visitor.visitEquivEntityGroup(self)
else:
return visitor.visitChildren(self)
[docs]
def equivEntityGroup(self):
localctx = Fortran77Parser.EquivEntityGroupContext(self, self._ctx, self.state)
self.enterRule(localctx, 50, self.RULE_equivEntityGroup)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 599
self.match(Fortran77Parser.LPAREN)
self.state = 600
self.equivEntity()
self.state = 605
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.COMMA:
self.state = 601
self.match(Fortran77Parser.COMMA)
self.state = 602
self.equivEntity()
self.state = 607
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 608
self.match(Fortran77Parser.RPAREN)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class EquivEntityContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def varRef(self):
return self.getTypedRuleContext(Fortran77Parser.VarRefContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_equivEntity
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEquivEntity" ):
listener.enterEquivEntity(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEquivEntity" ):
listener.exitEquivEntity(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEquivEntity" ):
return visitor.visitEquivEntity(self)
else:
return visitor.visitChildren(self)
[docs]
def equivEntity(self):
localctx = Fortran77Parser.EquivEntityContext(self, self._ctx, self.state)
self.enterRule(localctx, 52, self.RULE_equivEntity)
try:
self.enterOuterAlt(localctx, 1)
self.state = 610
self.varRef()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class CommonStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def COMMON(self):
return self.getToken(Fortran77Parser.COMMON, 0)
[docs]
def commonBlock(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.CommonBlockContext)
else:
return self.getTypedRuleContext(Fortran77Parser.CommonBlockContext,i)
[docs]
def commonItems(self):
return self.getTypedRuleContext(Fortran77Parser.CommonItemsContext,0)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.COMMA)
else:
return self.getToken(Fortran77Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_commonStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCommonStatement" ):
listener.enterCommonStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCommonStatement" ):
listener.exitCommonStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCommonStatement" ):
return visitor.visitCommonStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def commonStatement(self):
localctx = Fortran77Parser.CommonStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 54, self.RULE_commonStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 612
self.match(Fortran77Parser.COMMON)
self.state = 622
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran77Parser.DIV]:
self.state = 613
self.commonBlock()
self.state = 618
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.COMMA:
self.state = 614
self.match(Fortran77Parser.COMMA)
self.state = 615
self.commonBlock()
self.state = 620
self._errHandler.sync(self)
_la = self._input.LA(1)
pass
elif token in [Fortran77Parser.REAL, Fortran77Parser.NAME]:
self.state = 621
self.commonItems()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class CommonNameContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def DIV(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.DIV)
else:
return self.getToken(Fortran77Parser.DIV, i)
[docs]
def NAME(self):
return self.getToken(Fortran77Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_commonName
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCommonName" ):
listener.enterCommonName(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCommonName" ):
listener.exitCommonName(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCommonName" ):
return visitor.visitCommonName(self)
else:
return visitor.visitChildren(self)
[docs]
def commonName(self):
localctx = Fortran77Parser.CommonNameContext(self, self._ctx, self.state)
self.enterRule(localctx, 56, self.RULE_commonName)
try:
self.enterOuterAlt(localctx, 1)
self.state = 624
self.match(Fortran77Parser.DIV)
self.state = 628
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran77Parser.NAME]:
self.state = 625
self.match(Fortran77Parser.NAME)
self.state = 626
self.match(Fortran77Parser.DIV)
pass
elif token in [Fortran77Parser.DIV]:
self.state = 627
self.match(Fortran77Parser.DIV)
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class CommonItemContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def NAME(self):
return self.getToken(Fortran77Parser.NAME, 0)
[docs]
def arrayDeclarator(self):
return self.getTypedRuleContext(Fortran77Parser.ArrayDeclaratorContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_commonItem
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCommonItem" ):
listener.enterCommonItem(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCommonItem" ):
listener.exitCommonItem(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCommonItem" ):
return visitor.visitCommonItem(self)
else:
return visitor.visitChildren(self)
[docs]
def commonItem(self):
localctx = Fortran77Parser.CommonItemContext(self, self._ctx, self.state)
self.enterRule(localctx, 58, self.RULE_commonItem)
try:
self.state = 632
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,33,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 630
self.match(Fortran77Parser.NAME)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 631
self.arrayDeclarator()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class CommonItemsContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def commonItem(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.CommonItemContext)
else:
return self.getTypedRuleContext(Fortran77Parser.CommonItemContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.COMMA)
else:
return self.getToken(Fortran77Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_commonItems
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCommonItems" ):
listener.enterCommonItems(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCommonItems" ):
listener.exitCommonItems(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCommonItems" ):
return visitor.visitCommonItems(self)
else:
return visitor.visitChildren(self)
[docs]
def commonItems(self):
localctx = Fortran77Parser.CommonItemsContext(self, self._ctx, self.state)
self.enterRule(localctx, 60, self.RULE_commonItems)
try:
self.enterOuterAlt(localctx, 1)
self.state = 634
self.commonItem()
self.state = 639
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,34,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 635
self.match(Fortran77Parser.COMMA)
self.state = 636
self.commonItem()
self.state = 641
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,34,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class CommonBlockContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def commonName(self):
return self.getTypedRuleContext(Fortran77Parser.CommonNameContext,0)
[docs]
def commonItems(self):
return self.getTypedRuleContext(Fortran77Parser.CommonItemsContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_commonBlock
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCommonBlock" ):
listener.enterCommonBlock(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCommonBlock" ):
listener.exitCommonBlock(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCommonBlock" ):
return visitor.visitCommonBlock(self)
else:
return visitor.visitChildren(self)
[docs]
def commonBlock(self):
localctx = Fortran77Parser.CommonBlockContext(self, self._ctx, self.state)
self.enterRule(localctx, 62, self.RULE_commonBlock)
try:
self.enterOuterAlt(localctx, 1)
self.state = 642
self.commonName()
self.state = 643
self.commonItems()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class TypeStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def typename_(self):
return self.getTypedRuleContext(Fortran77Parser.Typename_Context,0)
[docs]
def typeStatementNameList(self):
return self.getTypedRuleContext(Fortran77Parser.TypeStatementNameListContext,0)
[docs]
def characterWithLen(self):
return self.getTypedRuleContext(Fortran77Parser.CharacterWithLenContext,0)
[docs]
def typeStatementNameCharList(self):
return self.getTypedRuleContext(Fortran77Parser.TypeStatementNameCharListContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_typeStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTypeStatement" ):
listener.enterTypeStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTypeStatement" ):
listener.exitTypeStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTypeStatement" ):
return visitor.visitTypeStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def typeStatement(self):
localctx = Fortran77Parser.TypeStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 64, self.RULE_typeStatement)
try:
self.state = 651
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 645
self.typename_()
self.state = 646
self.typeStatementNameList()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 648
self.characterWithLen()
self.state = 649
self.typeStatementNameCharList()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class TypeStatementNameListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def typeStatementName(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.TypeStatementNameContext)
else:
return self.getTypedRuleContext(Fortran77Parser.TypeStatementNameContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.COMMA)
else:
return self.getToken(Fortran77Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_typeStatementNameList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTypeStatementNameList" ):
listener.enterTypeStatementNameList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTypeStatementNameList" ):
listener.exitTypeStatementNameList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTypeStatementNameList" ):
return visitor.visitTypeStatementNameList(self)
else:
return visitor.visitChildren(self)
[docs]
def typeStatementNameList(self):
localctx = Fortran77Parser.TypeStatementNameListContext(self, self._ctx, self.state)
self.enterRule(localctx, 66, self.RULE_typeStatementNameList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 653
self.typeStatementName()
self.state = 658
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.COMMA:
self.state = 654
self.match(Fortran77Parser.COMMA)
self.state = 655
self.typeStatementName()
self.state = 660
self._errHandler.sync(self)
_la = self._input.LA(1)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class TypeStatementNameContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def NAME(self):
return self.getToken(Fortran77Parser.NAME, 0)
[docs]
def arrayDeclarator(self):
return self.getTypedRuleContext(Fortran77Parser.ArrayDeclaratorContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_typeStatementName
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTypeStatementName" ):
listener.enterTypeStatementName(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTypeStatementName" ):
listener.exitTypeStatementName(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTypeStatementName" ):
return visitor.visitTypeStatementName(self)
else:
return visitor.visitChildren(self)
[docs]
def typeStatementName(self):
localctx = Fortran77Parser.TypeStatementNameContext(self, self._ctx, self.state)
self.enterRule(localctx, 68, self.RULE_typeStatementName)
try:
self.state = 663
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,37,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 661
self.match(Fortran77Parser.NAME)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 662
self.arrayDeclarator()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class TypeStatementNameCharListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def typeStatementNameChar(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.TypeStatementNameCharContext)
else:
return self.getTypedRuleContext(Fortran77Parser.TypeStatementNameCharContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.COMMA)
else:
return self.getToken(Fortran77Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_typeStatementNameCharList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTypeStatementNameCharList" ):
listener.enterTypeStatementNameCharList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTypeStatementNameCharList" ):
listener.exitTypeStatementNameCharList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTypeStatementNameCharList" ):
return visitor.visitTypeStatementNameCharList(self)
else:
return visitor.visitChildren(self)
[docs]
def typeStatementNameCharList(self):
localctx = Fortran77Parser.TypeStatementNameCharListContext(self, self._ctx, self.state)
self.enterRule(localctx, 70, self.RULE_typeStatementNameCharList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 665
self.typeStatementNameChar()
self.state = 670
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.COMMA:
self.state = 666
self.match(Fortran77Parser.COMMA)
self.state = 667
self.typeStatementNameChar()
self.state = 672
self._errHandler.sync(self)
_la = self._input.LA(1)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class TypeStatementNameCharContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def typeStatementName(self):
return self.getTypedRuleContext(Fortran77Parser.TypeStatementNameContext,0)
[docs]
def typeStatementLenSpec(self):
return self.getTypedRuleContext(Fortran77Parser.TypeStatementLenSpecContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_typeStatementNameChar
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTypeStatementNameChar" ):
listener.enterTypeStatementNameChar(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTypeStatementNameChar" ):
listener.exitTypeStatementNameChar(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTypeStatementNameChar" ):
return visitor.visitTypeStatementNameChar(self)
else:
return visitor.visitChildren(self)
[docs]
def typeStatementNameChar(self):
localctx = Fortran77Parser.TypeStatementNameCharContext(self, self._ctx, self.state)
self.enterRule(localctx, 72, self.RULE_typeStatementNameChar)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 673
self.typeStatementName()
self.state = 675
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.STAR:
self.state = 674
self.typeStatementLenSpec()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class TypeStatementLenSpecContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def STAR(self):
return self.getToken(Fortran77Parser.STAR, 0)
[docs]
def lenSpecification(self):
return self.getTypedRuleContext(Fortran77Parser.LenSpecificationContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_typeStatementLenSpec
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTypeStatementLenSpec" ):
listener.enterTypeStatementLenSpec(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTypeStatementLenSpec" ):
listener.exitTypeStatementLenSpec(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTypeStatementLenSpec" ):
return visitor.visitTypeStatementLenSpec(self)
else:
return visitor.visitChildren(self)
[docs]
def typeStatementLenSpec(self):
localctx = Fortran77Parser.TypeStatementLenSpecContext(self, self._ctx, self.state)
self.enterRule(localctx, 74, self.RULE_typeStatementLenSpec)
try:
self.enterOuterAlt(localctx, 1)
self.state = 677
self.match(Fortran77Parser.STAR)
self.state = 678
self.lenSpecification()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Typename_Context(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def REAL(self):
return self.getToken(Fortran77Parser.REAL, 0)
[docs]
def COMPLEX(self):
return self.getToken(Fortran77Parser.COMPLEX, 0)
[docs]
def DOUBLE(self):
return self.getToken(Fortran77Parser.DOUBLE, 0)
[docs]
def PRECISION(self):
return self.getToken(Fortran77Parser.PRECISION, 0)
[docs]
def INTEGER(self):
return self.getToken(Fortran77Parser.INTEGER, 0)
[docs]
def LOGICAL(self):
return self.getToken(Fortran77Parser.LOGICAL, 0)
[docs]
def CHARACTER(self):
return self.getToken(Fortran77Parser.CHARACTER, 0)
[docs]
def STAR(self):
return self.getToken(Fortran77Parser.STAR, 0)
[docs]
def ICON(self):
return self.getToken(Fortran77Parser.ICON, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_typename_
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTypename_" ):
listener.enterTypename_(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTypename_" ):
listener.exitTypename_(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTypename_" ):
return visitor.visitTypename_(self)
else:
return visitor.visitChildren(self)
[docs]
def typename_(self):
localctx = Fortran77Parser.Typename_Context(self, self._ctx, self.state)
self.enterRule(localctx, 76, self.RULE_typename_)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 695
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,42,self._ctx)
if la_ == 1:
self.state = 680
self.match(Fortran77Parser.REAL)
pass
elif la_ == 2:
self.state = 681
self.match(Fortran77Parser.COMPLEX)
self.state = 686
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.STAR:
self.state = 682
self.match(Fortran77Parser.STAR)
self.state = 684
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.ICON:
self.state = 683
self.match(Fortran77Parser.ICON)
pass
elif la_ == 3:
self.state = 688
self.match(Fortran77Parser.DOUBLE)
self.state = 689
self.match(Fortran77Parser.COMPLEX)
pass
elif la_ == 4:
self.state = 690
self.match(Fortran77Parser.DOUBLE)
self.state = 691
self.match(Fortran77Parser.PRECISION)
pass
elif la_ == 5:
self.state = 692
self.match(Fortran77Parser.INTEGER)
pass
elif la_ == 6:
self.state = 693
self.match(Fortran77Parser.LOGICAL)
pass
elif la_ == 7:
self.state = 694
self.match(Fortran77Parser.CHARACTER)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Type_Context(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def typename_(self):
return self.getTypedRuleContext(Fortran77Parser.Typename_Context,0)
[docs]
def characterWithLen(self):
return self.getTypedRuleContext(Fortran77Parser.CharacterWithLenContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_type_
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterType_" ):
listener.enterType_(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitType_" ):
listener.exitType_(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitType_" ):
return visitor.visitType_(self)
else:
return visitor.visitChildren(self)
[docs]
def type_(self):
localctx = Fortran77Parser.Type_Context(self, self._ctx, self.state)
self.enterRule(localctx, 78, self.RULE_type_)
try:
self.state = 699
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,43,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 697
self.typename_()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 698
self.characterWithLen()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class TypenameLenContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def STAR(self):
return self.getToken(Fortran77Parser.STAR, 0)
[docs]
def ICON(self):
return self.getToken(Fortran77Parser.ICON, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_typenameLen
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTypenameLen" ):
listener.enterTypenameLen(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTypenameLen" ):
listener.exitTypenameLen(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTypenameLen" ):
return visitor.visitTypenameLen(self)
else:
return visitor.visitChildren(self)
[docs]
def typenameLen(self):
localctx = Fortran77Parser.TypenameLenContext(self, self._ctx, self.state)
self.enterRule(localctx, 80, self.RULE_typenameLen)
try:
self.enterOuterAlt(localctx, 1)
self.state = 701
self.match(Fortran77Parser.STAR)
self.state = 702
self.match(Fortran77Parser.ICON)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class PointerStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def POINTER(self):
return self.getToken(Fortran77Parser.POINTER, 0)
[docs]
def pointerDecl(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.PointerDeclContext)
else:
return self.getTypedRuleContext(Fortran77Parser.PointerDeclContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.COMMA)
else:
return self.getToken(Fortran77Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_pointerStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPointerStatement" ):
listener.enterPointerStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPointerStatement" ):
listener.exitPointerStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPointerStatement" ):
return visitor.visitPointerStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def pointerStatement(self):
localctx = Fortran77Parser.PointerStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 82, self.RULE_pointerStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 704
self.match(Fortran77Parser.POINTER)
self.state = 705
self.pointerDecl()
self.state = 710
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.COMMA:
self.state = 706
self.match(Fortran77Parser.COMMA)
self.state = 707
self.pointerDecl()
self.state = 712
self._errHandler.sync(self)
_la = self._input.LA(1)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class PointerDeclContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def LPAREN(self):
return self.getToken(Fortran77Parser.LPAREN, 0)
[docs]
def NAME(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.NAME)
else:
return self.getToken(Fortran77Parser.NAME, i)
[docs]
def COMMA(self):
return self.getToken(Fortran77Parser.COMMA, 0)
[docs]
def RPAREN(self):
return self.getToken(Fortran77Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_pointerDecl
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPointerDecl" ):
listener.enterPointerDecl(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPointerDecl" ):
listener.exitPointerDecl(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPointerDecl" ):
return visitor.visitPointerDecl(self)
else:
return visitor.visitChildren(self)
[docs]
def pointerDecl(self):
localctx = Fortran77Parser.PointerDeclContext(self, self._ctx, self.state)
self.enterRule(localctx, 84, self.RULE_pointerDecl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 713
self.match(Fortran77Parser.LPAREN)
self.state = 714
self.match(Fortran77Parser.NAME)
self.state = 715
self.match(Fortran77Parser.COMMA)
self.state = 716
self.match(Fortran77Parser.NAME)
self.state = 717
self.match(Fortran77Parser.RPAREN)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ImplicitStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def IMPLICIT(self):
return self.getToken(Fortran77Parser.IMPLICIT, 0)
[docs]
def implicitNone(self):
return self.getTypedRuleContext(Fortran77Parser.ImplicitNoneContext,0)
[docs]
def implicitSpecs(self):
return self.getTypedRuleContext(Fortran77Parser.ImplicitSpecsContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_implicitStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterImplicitStatement" ):
listener.enterImplicitStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitImplicitStatement" ):
listener.exitImplicitStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitImplicitStatement" ):
return visitor.visitImplicitStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def implicitStatement(self):
localctx = Fortran77Parser.ImplicitStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 86, self.RULE_implicitStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 719
self.match(Fortran77Parser.IMPLICIT)
self.state = 722
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran77Parser.NONE]:
self.state = 720
self.implicitNone()
pass
elif token in [Fortran77Parser.REAL, Fortran77Parser.CHARACTER, Fortran77Parser.DOUBLE, Fortran77Parser.LPAREN, Fortran77Parser.MINUS, Fortran77Parser.PLUS, Fortran77Parser.LNOT, Fortran77Parser.TRUE, Fortran77Parser.FALSE, Fortran77Parser.HOLLERITH, Fortran77Parser.COMPLEX, Fortran77Parser.INTEGER, Fortran77Parser.LOGICAL, Fortran77Parser.SCON, Fortran77Parser.RCON, Fortran77Parser.ICON, Fortran77Parser.NAME]:
self.state = 721
self.implicitSpecs()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ImplicitSpecContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def type_(self):
return self.getTypedRuleContext(Fortran77Parser.Type_Context,0)
[docs]
def LPAREN(self):
return self.getToken(Fortran77Parser.LPAREN, 0)
[docs]
def implicitLetters(self):
return self.getTypedRuleContext(Fortran77Parser.ImplicitLettersContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran77Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_implicitSpec
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterImplicitSpec" ):
listener.enterImplicitSpec(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitImplicitSpec" ):
listener.exitImplicitSpec(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitImplicitSpec" ):
return visitor.visitImplicitSpec(self)
else:
return visitor.visitChildren(self)
[docs]
def implicitSpec(self):
localctx = Fortran77Parser.ImplicitSpecContext(self, self._ctx, self.state)
self.enterRule(localctx, 88, self.RULE_implicitSpec)
try:
self.enterOuterAlt(localctx, 1)
self.state = 724
self.type_()
self.state = 725
self.match(Fortran77Parser.LPAREN)
self.state = 726
self.implicitLetters()
self.state = 727
self.match(Fortran77Parser.RPAREN)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ImplicitSpecsContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def implicitSpec(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.ImplicitSpecContext)
else:
return self.getTypedRuleContext(Fortran77Parser.ImplicitSpecContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.COMMA)
else:
return self.getToken(Fortran77Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_implicitSpecs
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterImplicitSpecs" ):
listener.enterImplicitSpecs(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitImplicitSpecs" ):
listener.exitImplicitSpecs(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitImplicitSpecs" ):
return visitor.visitImplicitSpecs(self)
else:
return visitor.visitChildren(self)
[docs]
def implicitSpecs(self):
localctx = Fortran77Parser.ImplicitSpecsContext(self, self._ctx, self.state)
self.enterRule(localctx, 90, self.RULE_implicitSpecs)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 729
self.implicitSpec()
self.state = 734
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.COMMA:
self.state = 730
self.match(Fortran77Parser.COMMA)
self.state = 731
self.implicitSpec()
self.state = 736
self._errHandler.sync(self)
_la = self._input.LA(1)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ImplicitNoneContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def NONE(self):
return self.getToken(Fortran77Parser.NONE, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_implicitNone
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterImplicitNone" ):
listener.enterImplicitNone(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitImplicitNone" ):
listener.exitImplicitNone(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitImplicitNone" ):
return visitor.visitImplicitNone(self)
else:
return visitor.visitChildren(self)
[docs]
def implicitNone(self):
localctx = Fortran77Parser.ImplicitNoneContext(self, self._ctx, self.state)
self.enterRule(localctx, 92, self.RULE_implicitNone)
try:
self.enterOuterAlt(localctx, 1)
self.state = 737
self.match(Fortran77Parser.NONE)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ImplicitLetterContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def NAME(self):
return self.getToken(Fortran77Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_implicitLetter
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterImplicitLetter" ):
listener.enterImplicitLetter(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitImplicitLetter" ):
listener.exitImplicitLetter(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitImplicitLetter" ):
return visitor.visitImplicitLetter(self)
else:
return visitor.visitChildren(self)
[docs]
def implicitLetter(self):
localctx = Fortran77Parser.ImplicitLetterContext(self, self._ctx, self.state)
self.enterRule(localctx, 94, self.RULE_implicitLetter)
try:
self.enterOuterAlt(localctx, 1)
self.state = 739
self.match(Fortran77Parser.NAME)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ImplicitRangeContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def implicitLetter(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.ImplicitLetterContext)
else:
return self.getTypedRuleContext(Fortran77Parser.ImplicitLetterContext,i)
[docs]
def MINUS(self):
return self.getToken(Fortran77Parser.MINUS, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_implicitRange
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterImplicitRange" ):
listener.enterImplicitRange(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitImplicitRange" ):
listener.exitImplicitRange(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitImplicitRange" ):
return visitor.visitImplicitRange(self)
else:
return visitor.visitChildren(self)
[docs]
def implicitRange(self):
localctx = Fortran77Parser.ImplicitRangeContext(self, self._ctx, self.state)
self.enterRule(localctx, 96, self.RULE_implicitRange)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 741
self.implicitLetter()
self.state = 744
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.MINUS:
self.state = 742
self.match(Fortran77Parser.MINUS)
self.state = 743
self.implicitLetter()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ImplicitLettersContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def implicitRange(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.ImplicitRangeContext)
else:
return self.getTypedRuleContext(Fortran77Parser.ImplicitRangeContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.COMMA)
else:
return self.getToken(Fortran77Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_implicitLetters
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterImplicitLetters" ):
listener.enterImplicitLetters(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitImplicitLetters" ):
listener.exitImplicitLetters(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitImplicitLetters" ):
return visitor.visitImplicitLetters(self)
else:
return visitor.visitChildren(self)
[docs]
def implicitLetters(self):
localctx = Fortran77Parser.ImplicitLettersContext(self, self._ctx, self.state)
self.enterRule(localctx, 98, self.RULE_implicitLetters)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 746
self.implicitRange()
self.state = 751
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.COMMA:
self.state = 747
self.match(Fortran77Parser.COMMA)
self.state = 748
self.implicitRange()
self.state = 753
self._errHandler.sync(self)
_la = self._input.LA(1)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class LenSpecificationContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def LPAREN(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.LPAREN)
else:
return self.getToken(Fortran77Parser.LPAREN, i)
[docs]
def STAR(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.STAR)
else:
return self.getToken(Fortran77Parser.STAR, i)
[docs]
def RPAREN(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.RPAREN)
else:
return self.getToken(Fortran77Parser.RPAREN, i)
[docs]
def ICON(self):
return self.getToken(Fortran77Parser.ICON, 0)
[docs]
def intConstantExpr(self):
return self.getTypedRuleContext(Fortran77Parser.IntConstantExprContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_lenSpecification
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLenSpecification" ):
listener.enterLenSpecification(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLenSpecification" ):
listener.exitLenSpecification(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLenSpecification" ):
return visitor.visitLenSpecification(self)
else:
return visitor.visitChildren(self)
[docs]
def lenSpecification(self):
localctx = Fortran77Parser.LenSpecificationContext(self, self._ctx, self.state)
self.enterRule(localctx, 100, self.RULE_lenSpecification)
try:
self.state = 766
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,49,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 754
self.match(Fortran77Parser.LPAREN)
self.state = 755
self.match(Fortran77Parser.STAR)
self.state = 756
self.match(Fortran77Parser.RPAREN)
self.state = 758
self.match(Fortran77Parser.LPAREN)
self.state = 759
self.match(Fortran77Parser.STAR)
self.state = 760
self.match(Fortran77Parser.RPAREN)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 761
self.match(Fortran77Parser.ICON)
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 762
self.match(Fortran77Parser.LPAREN)
self.state = 763
self.intConstantExpr()
self.state = 764
self.match(Fortran77Parser.RPAREN)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class CharacterWithLenContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def characterExpression(self):
return self.getTypedRuleContext(Fortran77Parser.CharacterExpressionContext,0)
[docs]
def cwlLen(self):
return self.getTypedRuleContext(Fortran77Parser.CwlLenContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_characterWithLen
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCharacterWithLen" ):
listener.enterCharacterWithLen(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCharacterWithLen" ):
listener.exitCharacterWithLen(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCharacterWithLen" ):
return visitor.visitCharacterWithLen(self)
else:
return visitor.visitChildren(self)
[docs]
def characterWithLen(self):
localctx = Fortran77Parser.CharacterWithLenContext(self, self._ctx, self.state)
self.enterRule(localctx, 102, self.RULE_characterWithLen)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 768
self.characterExpression()
self.state = 770
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.STAR:
self.state = 769
self.cwlLen()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class CwlLenContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def STAR(self):
return self.getToken(Fortran77Parser.STAR, 0)
[docs]
def lenSpecification(self):
return self.getTypedRuleContext(Fortran77Parser.LenSpecificationContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_cwlLen
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCwlLen" ):
listener.enterCwlLen(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCwlLen" ):
listener.exitCwlLen(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCwlLen" ):
return visitor.visitCwlLen(self)
else:
return visitor.visitChildren(self)
[docs]
def cwlLen(self):
localctx = Fortran77Parser.CwlLenContext(self, self._ctx, self.state)
self.enterRule(localctx, 104, self.RULE_cwlLen)
try:
self.enterOuterAlt(localctx, 1)
self.state = 772
self.match(Fortran77Parser.STAR)
self.state = 773
self.lenSpecification()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ParameterStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def PARAMETER(self):
return self.getToken(Fortran77Parser.PARAMETER, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran77Parser.LPAREN, 0)
[docs]
def paramlist(self):
return self.getTypedRuleContext(Fortran77Parser.ParamlistContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran77Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_parameterStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterParameterStatement" ):
listener.enterParameterStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitParameterStatement" ):
listener.exitParameterStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitParameterStatement" ):
return visitor.visitParameterStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def parameterStatement(self):
localctx = Fortran77Parser.ParameterStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 106, self.RULE_parameterStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 775
self.match(Fortran77Parser.PARAMETER)
self.state = 776
self.match(Fortran77Parser.LPAREN)
self.state = 777
self.paramlist()
self.state = 778
self.match(Fortran77Parser.RPAREN)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ParamlistContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def paramassign(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.ParamassignContext)
else:
return self.getTypedRuleContext(Fortran77Parser.ParamassignContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.COMMA)
else:
return self.getToken(Fortran77Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_paramlist
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterParamlist" ):
listener.enterParamlist(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitParamlist" ):
listener.exitParamlist(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitParamlist" ):
return visitor.visitParamlist(self)
else:
return visitor.visitChildren(self)
[docs]
def paramlist(self):
localctx = Fortran77Parser.ParamlistContext(self, self._ctx, self.state)
self.enterRule(localctx, 108, self.RULE_paramlist)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 780
self.paramassign()
self.state = 785
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.COMMA:
self.state = 781
self.match(Fortran77Parser.COMMA)
self.state = 782
self.paramassign()
self.state = 787
self._errHandler.sync(self)
_la = self._input.LA(1)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ParamassignContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def NAME(self):
return self.getToken(Fortran77Parser.NAME, 0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran77Parser.ASSIGN, 0)
[docs]
def constantExpr(self):
return self.getTypedRuleContext(Fortran77Parser.ConstantExprContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_paramassign
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterParamassign" ):
listener.enterParamassign(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitParamassign" ):
listener.exitParamassign(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitParamassign" ):
return visitor.visitParamassign(self)
else:
return visitor.visitChildren(self)
[docs]
def paramassign(self):
localctx = Fortran77Parser.ParamassignContext(self, self._ctx, self.state)
self.enterRule(localctx, 110, self.RULE_paramassign)
try:
self.enterOuterAlt(localctx, 1)
self.state = 788
self.match(Fortran77Parser.NAME)
self.state = 789
self.match(Fortran77Parser.ASSIGN)
self.state = 790
self.constantExpr()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ExternalStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def EXTERNAL(self):
return self.getToken(Fortran77Parser.EXTERNAL, 0)
[docs]
def namelist(self):
return self.getTypedRuleContext(Fortran77Parser.NamelistContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_externalStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterExternalStatement" ):
listener.enterExternalStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitExternalStatement" ):
listener.exitExternalStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitExternalStatement" ):
return visitor.visitExternalStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def externalStatement(self):
localctx = Fortran77Parser.ExternalStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 112, self.RULE_externalStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 792
self.match(Fortran77Parser.EXTERNAL)
self.state = 793
self.namelist()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class IntrinsicStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def INTRINSIC(self):
return self.getToken(Fortran77Parser.INTRINSIC, 0)
[docs]
def namelist(self):
return self.getTypedRuleContext(Fortran77Parser.NamelistContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_intrinsicStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIntrinsicStatement" ):
listener.enterIntrinsicStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIntrinsicStatement" ):
listener.exitIntrinsicStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIntrinsicStatement" ):
return visitor.visitIntrinsicStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def intrinsicStatement(self):
localctx = Fortran77Parser.IntrinsicStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 114, self.RULE_intrinsicStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 795
self.match(Fortran77Parser.INTRINSIC)
self.state = 796
self.namelist()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class SaveStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def SAVE(self):
return self.getToken(Fortran77Parser.SAVE, 0)
[docs]
def saveEntity(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.SaveEntityContext)
else:
return self.getTypedRuleContext(Fortran77Parser.SaveEntityContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.COMMA)
else:
return self.getToken(Fortran77Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_saveStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSaveStatement" ):
listener.enterSaveStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSaveStatement" ):
listener.exitSaveStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSaveStatement" ):
return visitor.visitSaveStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def saveStatement(self):
localctx = Fortran77Parser.SaveStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 116, self.RULE_saveStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 798
self.match(Fortran77Parser.SAVE)
self.state = 807
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.DIV or _la==Fortran77Parser.NAME:
self.state = 799
self.saveEntity()
self.state = 804
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.COMMA:
self.state = 800
self.match(Fortran77Parser.COMMA)
self.state = 801
self.saveEntity()
self.state = 806
self._errHandler.sync(self)
_la = self._input.LA(1)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class SaveEntityContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def NAME(self):
return self.getToken(Fortran77Parser.NAME, 0)
[docs]
def DIV(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.DIV)
else:
return self.getToken(Fortran77Parser.DIV, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_saveEntity
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSaveEntity" ):
listener.enterSaveEntity(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSaveEntity" ):
listener.exitSaveEntity(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSaveEntity" ):
return visitor.visitSaveEntity(self)
else:
return visitor.visitChildren(self)
[docs]
def saveEntity(self):
localctx = Fortran77Parser.SaveEntityContext(self, self._ctx, self.state)
self.enterRule(localctx, 118, self.RULE_saveEntity)
try:
self.enterOuterAlt(localctx, 1)
self.state = 813
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran77Parser.NAME]:
self.state = 809
self.match(Fortran77Parser.NAME)
pass
elif token in [Fortran77Parser.DIV]:
self.state = 810
self.match(Fortran77Parser.DIV)
self.state = 811
self.match(Fortran77Parser.NAME)
self.state = 812
self.match(Fortran77Parser.DIV)
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class DataStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def DATA(self):
return self.getToken(Fortran77Parser.DATA, 0)
[docs]
def dataStatementEntity(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.DataStatementEntityContext)
else:
return self.getTypedRuleContext(Fortran77Parser.DataStatementEntityContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.COMMA)
else:
return self.getToken(Fortran77Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_dataStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDataStatement" ):
listener.enterDataStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDataStatement" ):
listener.exitDataStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDataStatement" ):
return visitor.visitDataStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def dataStatement(self):
localctx = Fortran77Parser.DataStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 120, self.RULE_dataStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 815
self.match(Fortran77Parser.DATA)
self.state = 816
self.dataStatementEntity()
self.state = 823
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.REAL or ((((_la - 69)) & ~0x3f) == 0 and ((1 << (_la - 69)) & ((1 << (Fortran77Parser.COMMA - 69)) | (1 << (Fortran77Parser.LPAREN - 69)) | (1 << (Fortran77Parser.NAME - 69)))) != 0):
self.state = 818
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.COMMA:
self.state = 817
self.match(Fortran77Parser.COMMA)
self.state = 820
self.dataStatementEntity()
self.state = 825
self._errHandler.sync(self)
_la = self._input.LA(1)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class DataStatementItemContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def varRef(self):
return self.getTypedRuleContext(Fortran77Parser.VarRefContext,0)
[docs]
def dataImpliedDo(self):
return self.getTypedRuleContext(Fortran77Parser.DataImpliedDoContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_dataStatementItem
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDataStatementItem" ):
listener.enterDataStatementItem(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDataStatementItem" ):
listener.exitDataStatementItem(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDataStatementItem" ):
return visitor.visitDataStatementItem(self)
else:
return visitor.visitChildren(self)
[docs]
def dataStatementItem(self):
localctx = Fortran77Parser.DataStatementItemContext(self, self._ctx, self.state)
self.enterRule(localctx, 122, self.RULE_dataStatementItem)
try:
self.state = 828
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran77Parser.REAL, Fortran77Parser.NAME]:
self.enterOuterAlt(localctx, 1)
self.state = 826
self.varRef()
pass
elif token in [Fortran77Parser.LPAREN]:
self.enterOuterAlt(localctx, 2)
self.state = 827
self.dataImpliedDo()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class DataStatementMultipleContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def constant(self):
return self.getTypedRuleContext(Fortran77Parser.ConstantContext,0)
[docs]
def NAME(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.NAME)
else:
return self.getToken(Fortran77Parser.NAME, i)
[docs]
def STAR(self):
return self.getToken(Fortran77Parser.STAR, 0)
[docs]
def ICON(self):
return self.getToken(Fortran77Parser.ICON, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_dataStatementMultiple
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDataStatementMultiple" ):
listener.enterDataStatementMultiple(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDataStatementMultiple" ):
listener.exitDataStatementMultiple(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDataStatementMultiple" ):
return visitor.visitDataStatementMultiple(self)
else:
return visitor.visitChildren(self)
[docs]
def dataStatementMultiple(self):
localctx = Fortran77Parser.DataStatementMultipleContext(self, self._ctx, self.state)
self.enterRule(localctx, 124, self.RULE_dataStatementMultiple)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 832
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,58,self._ctx)
if la_ == 1:
self.state = 830
_la = self._input.LA(1)
if not(_la==Fortran77Parser.ICON or _la==Fortran77Parser.NAME):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 831
self.match(Fortran77Parser.STAR)
self.state = 836
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran77Parser.LPAREN, Fortran77Parser.MINUS, Fortran77Parser.PLUS, Fortran77Parser.TRUE, Fortran77Parser.FALSE, Fortran77Parser.HOLLERITH, Fortran77Parser.SCON, Fortran77Parser.RCON, Fortran77Parser.ICON]:
self.state = 834
self.constant()
pass
elif token in [Fortran77Parser.NAME]:
self.state = 835
self.match(Fortran77Parser.NAME)
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class DataStatementEntityContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def dse1(self):
return self.getTypedRuleContext(Fortran77Parser.Dse1Context,0)
[docs]
def dse2(self):
return self.getTypedRuleContext(Fortran77Parser.Dse2Context,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_dataStatementEntity
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDataStatementEntity" ):
listener.enterDataStatementEntity(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDataStatementEntity" ):
listener.exitDataStatementEntity(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDataStatementEntity" ):
return visitor.visitDataStatementEntity(self)
else:
return visitor.visitChildren(self)
[docs]
def dataStatementEntity(self):
localctx = Fortran77Parser.DataStatementEntityContext(self, self._ctx, self.state)
self.enterRule(localctx, 126, self.RULE_dataStatementEntity)
try:
self.enterOuterAlt(localctx, 1)
self.state = 838
self.dse1()
self.state = 839
self.dse2()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Dse1Context(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def dataStatementItem(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.DataStatementItemContext)
else:
return self.getTypedRuleContext(Fortran77Parser.DataStatementItemContext,i)
[docs]
def DIV(self):
return self.getToken(Fortran77Parser.DIV, 0)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.COMMA)
else:
return self.getToken(Fortran77Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_dse1
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDse1" ):
listener.enterDse1(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDse1" ):
listener.exitDse1(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDse1" ):
return visitor.visitDse1(self)
else:
return visitor.visitChildren(self)
[docs]
def dse1(self):
localctx = Fortran77Parser.Dse1Context(self, self._ctx, self.state)
self.enterRule(localctx, 128, self.RULE_dse1)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 841
self.dataStatementItem()
self.state = 846
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.COMMA:
self.state = 842
self.match(Fortran77Parser.COMMA)
self.state = 843
self.dataStatementItem()
self.state = 848
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 849
self.match(Fortran77Parser.DIV)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Dse2Context(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def dataStatementMultiple(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.DataStatementMultipleContext)
else:
return self.getTypedRuleContext(Fortran77Parser.DataStatementMultipleContext,i)
[docs]
def DIV(self):
return self.getToken(Fortran77Parser.DIV, 0)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.COMMA)
else:
return self.getToken(Fortran77Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_dse2
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDse2" ):
listener.enterDse2(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDse2" ):
listener.exitDse2(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDse2" ):
return visitor.visitDse2(self)
else:
return visitor.visitChildren(self)
[docs]
def dse2(self):
localctx = Fortran77Parser.Dse2Context(self, self._ctx, self.state)
self.enterRule(localctx, 130, self.RULE_dse2)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 851
self.dataStatementMultiple()
self.state = 856
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.COMMA:
self.state = 852
self.match(Fortran77Parser.COMMA)
self.state = 853
self.dataStatementMultiple()
self.state = 858
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 859
self.match(Fortran77Parser.DIV)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class DataImpliedDoContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def LPAREN(self):
return self.getToken(Fortran77Parser.LPAREN, 0)
[docs]
def dataImpliedDoList(self):
return self.getTypedRuleContext(Fortran77Parser.DataImpliedDoListContext,0)
[docs]
def COMMA(self):
return self.getToken(Fortran77Parser.COMMA, 0)
[docs]
def dataImpliedDoRange(self):
return self.getTypedRuleContext(Fortran77Parser.DataImpliedDoRangeContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran77Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_dataImpliedDo
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDataImpliedDo" ):
listener.enterDataImpliedDo(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDataImpliedDo" ):
listener.exitDataImpliedDo(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDataImpliedDo" ):
return visitor.visitDataImpliedDo(self)
else:
return visitor.visitChildren(self)
[docs]
def dataImpliedDo(self):
localctx = Fortran77Parser.DataImpliedDoContext(self, self._ctx, self.state)
self.enterRule(localctx, 132, self.RULE_dataImpliedDo)
try:
self.enterOuterAlt(localctx, 1)
self.state = 861
self.match(Fortran77Parser.LPAREN)
self.state = 862
self.dataImpliedDoList()
self.state = 863
self.match(Fortran77Parser.COMMA)
self.state = 864
self.dataImpliedDoRange()
self.state = 865
self.match(Fortran77Parser.RPAREN)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class DataImpliedDoRangeContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def NAME(self):
return self.getToken(Fortran77Parser.NAME, 0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran77Parser.ASSIGN, 0)
[docs]
def intConstantExpr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.IntConstantExprContext)
else:
return self.getTypedRuleContext(Fortran77Parser.IntConstantExprContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.COMMA)
else:
return self.getToken(Fortran77Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_dataImpliedDoRange
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDataImpliedDoRange" ):
listener.enterDataImpliedDoRange(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDataImpliedDoRange" ):
listener.exitDataImpliedDoRange(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDataImpliedDoRange" ):
return visitor.visitDataImpliedDoRange(self)
else:
return visitor.visitChildren(self)
[docs]
def dataImpliedDoRange(self):
localctx = Fortran77Parser.DataImpliedDoRangeContext(self, self._ctx, self.state)
self.enterRule(localctx, 134, self.RULE_dataImpliedDoRange)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 867
self.match(Fortran77Parser.NAME)
self.state = 868
self.match(Fortran77Parser.ASSIGN)
self.state = 869
self.intConstantExpr()
self.state = 870
self.match(Fortran77Parser.COMMA)
self.state = 871
self.intConstantExpr()
self.state = 874
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.COMMA:
self.state = 872
self.match(Fortran77Parser.COMMA)
self.state = 873
self.intConstantExpr()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class DataImpliedDoListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def dataImpliedDoListWhat(self):
return self.getTypedRuleContext(Fortran77Parser.DataImpliedDoListWhatContext,0)
[docs]
def COMMA(self):
return self.getToken(Fortran77Parser.COMMA, 0)
[docs]
def dataImpliedDoList(self):
return self.getTypedRuleContext(Fortran77Parser.DataImpliedDoListContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_dataImpliedDoList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDataImpliedDoList" ):
listener.enterDataImpliedDoList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDataImpliedDoList" ):
listener.exitDataImpliedDoList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDataImpliedDoList" ):
return visitor.visitDataImpliedDoList(self)
else:
return visitor.visitChildren(self)
[docs]
def dataImpliedDoList(self):
localctx = Fortran77Parser.DataImpliedDoListContext(self, self._ctx, self.state)
self.enterRule(localctx, 136, self.RULE_dataImpliedDoList)
try:
self.state = 879
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran77Parser.REAL, Fortran77Parser.LPAREN, Fortran77Parser.NAME]:
self.enterOuterAlt(localctx, 1)
self.state = 876
self.dataImpliedDoListWhat()
pass
elif token in [Fortran77Parser.COMMA]:
self.enterOuterAlt(localctx, 2)
self.state = 877
self.match(Fortran77Parser.COMMA)
self.state = 878
self.dataImpliedDoList()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class DataImpliedDoListWhatContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def varRef(self):
return self.getTypedRuleContext(Fortran77Parser.VarRefContext,0)
[docs]
def dataImpliedDo(self):
return self.getTypedRuleContext(Fortran77Parser.DataImpliedDoContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_dataImpliedDoListWhat
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDataImpliedDoListWhat" ):
listener.enterDataImpliedDoListWhat(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDataImpliedDoListWhat" ):
listener.exitDataImpliedDoListWhat(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDataImpliedDoListWhat" ):
return visitor.visitDataImpliedDoListWhat(self)
else:
return visitor.visitChildren(self)
[docs]
def dataImpliedDoListWhat(self):
localctx = Fortran77Parser.DataImpliedDoListWhatContext(self, self._ctx, self.state)
self.enterRule(localctx, 138, self.RULE_dataImpliedDoListWhat)
try:
self.enterOuterAlt(localctx, 1)
self.state = 883
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran77Parser.REAL, Fortran77Parser.NAME]:
self.state = 881
self.varRef()
pass
elif token in [Fortran77Parser.LPAREN]:
self.state = 882
self.dataImpliedDo()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class GotoStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def to(self):
return self.getTypedRuleContext(Fortran77Parser.ToContext,0)
[docs]
def unconditionalGoto(self):
return self.getTypedRuleContext(Fortran77Parser.UnconditionalGotoContext,0)
[docs]
def computedGoto(self):
return self.getTypedRuleContext(Fortran77Parser.ComputedGotoContext,0)
[docs]
def assignedGoto(self):
return self.getTypedRuleContext(Fortran77Parser.AssignedGotoContext,0)
[docs]
def GO(self):
return self.getToken(Fortran77Parser.GO, 0)
[docs]
def GOTO(self):
return self.getToken(Fortran77Parser.GOTO, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_gotoStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterGotoStatement" ):
listener.enterGotoStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitGotoStatement" ):
listener.exitGotoStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitGotoStatement" ):
return visitor.visitGotoStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def gotoStatement(self):
localctx = Fortran77Parser.GotoStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 140, self.RULE_gotoStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 885
_la = self._input.LA(1)
if not(_la==Fortran77Parser.GO or _la==Fortran77Parser.GOTO):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 886
self.to()
self.state = 891
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran77Parser.ICON]:
self.state = 888
self.unconditionalGoto()
pass
elif token in [Fortran77Parser.LPAREN]:
self.state = 889
self.computedGoto()
pass
elif token in [Fortran77Parser.NAME]:
self.state = 890
self.assignedGoto()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class UnconditionalGotoContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def lblRef(self):
return self.getTypedRuleContext(Fortran77Parser.LblRefContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_unconditionalGoto
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterUnconditionalGoto" ):
listener.enterUnconditionalGoto(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitUnconditionalGoto" ):
listener.exitUnconditionalGoto(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitUnconditionalGoto" ):
return visitor.visitUnconditionalGoto(self)
else:
return visitor.visitChildren(self)
[docs]
def unconditionalGoto(self):
localctx = Fortran77Parser.UnconditionalGotoContext(self, self._ctx, self.state)
self.enterRule(localctx, 142, self.RULE_unconditionalGoto)
try:
self.enterOuterAlt(localctx, 1)
self.state = 893
self.lblRef()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ComputedGotoContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def LPAREN(self):
return self.getToken(Fortran77Parser.LPAREN, 0)
[docs]
def labelList(self):
return self.getTypedRuleContext(Fortran77Parser.LabelListContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran77Parser.RPAREN, 0)
[docs]
def integerExpr(self):
return self.getTypedRuleContext(Fortran77Parser.IntegerExprContext,0)
[docs]
def COMMA(self):
return self.getToken(Fortran77Parser.COMMA, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_computedGoto
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterComputedGoto" ):
listener.enterComputedGoto(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitComputedGoto" ):
listener.exitComputedGoto(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitComputedGoto" ):
return visitor.visitComputedGoto(self)
else:
return visitor.visitChildren(self)
[docs]
def computedGoto(self):
localctx = Fortran77Parser.ComputedGotoContext(self, self._ctx, self.state)
self.enterRule(localctx, 144, self.RULE_computedGoto)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 895
self.match(Fortran77Parser.LPAREN)
self.state = 896
self.labelList()
self.state = 897
self.match(Fortran77Parser.RPAREN)
self.state = 899
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.COMMA:
self.state = 898
self.match(Fortran77Parser.COMMA)
self.state = 901
self.integerExpr()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class LblRefContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ICON(self):
return self.getToken(Fortran77Parser.ICON, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_lblRef
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLblRef" ):
listener.enterLblRef(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLblRef" ):
listener.exitLblRef(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLblRef" ):
return visitor.visitLblRef(self)
else:
return visitor.visitChildren(self)
[docs]
def lblRef(self):
localctx = Fortran77Parser.LblRefContext(self, self._ctx, self.state)
self.enterRule(localctx, 146, self.RULE_lblRef)
try:
self.enterOuterAlt(localctx, 1)
self.state = 903
self.match(Fortran77Parser.ICON)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class LabelListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def lblRef(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.LblRefContext)
else:
return self.getTypedRuleContext(Fortran77Parser.LblRefContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.COMMA)
else:
return self.getToken(Fortran77Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_labelList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLabelList" ):
listener.enterLabelList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLabelList" ):
listener.exitLabelList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLabelList" ):
return visitor.visitLabelList(self)
else:
return visitor.visitChildren(self)
[docs]
def labelList(self):
localctx = Fortran77Parser.LabelListContext(self, self._ctx, self.state)
self.enterRule(localctx, 148, self.RULE_labelList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 905
self.lblRef()
self.state = 910
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.COMMA:
self.state = 906
self.match(Fortran77Parser.COMMA)
self.state = 907
self.lblRef()
self.state = 912
self._errHandler.sync(self)
_la = self._input.LA(1)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class AssignedGotoContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def NAME(self):
return self.getToken(Fortran77Parser.NAME, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran77Parser.LPAREN, 0)
[docs]
def labelList(self):
return self.getTypedRuleContext(Fortran77Parser.LabelListContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran77Parser.RPAREN, 0)
[docs]
def COMMA(self):
return self.getToken(Fortran77Parser.COMMA, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_assignedGoto
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAssignedGoto" ):
listener.enterAssignedGoto(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAssignedGoto" ):
listener.exitAssignedGoto(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAssignedGoto" ):
return visitor.visitAssignedGoto(self)
else:
return visitor.visitChildren(self)
[docs]
def assignedGoto(self):
localctx = Fortran77Parser.AssignedGotoContext(self, self._ctx, self.state)
self.enterRule(localctx, 150, self.RULE_assignedGoto)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 913
self.match(Fortran77Parser.NAME)
self.state = 921
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.COMMA or _la==Fortran77Parser.LPAREN:
self.state = 915
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.COMMA:
self.state = 914
self.match(Fortran77Parser.COMMA)
self.state = 917
self.match(Fortran77Parser.LPAREN)
self.state = 918
self.labelList()
self.state = 919
self.match(Fortran77Parser.RPAREN)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class IfStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def IF(self):
return self.getToken(Fortran77Parser.IF, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran77Parser.LPAREN, 0)
[docs]
def logicalExpression(self):
return self.getTypedRuleContext(Fortran77Parser.LogicalExpressionContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran77Parser.RPAREN, 0)
[docs]
def blockIfStatement(self):
return self.getTypedRuleContext(Fortran77Parser.BlockIfStatementContext,0)
[docs]
def logicalIfStatement(self):
return self.getTypedRuleContext(Fortran77Parser.LogicalIfStatementContext,0)
[docs]
def arithmeticIfStatement(self):
return self.getTypedRuleContext(Fortran77Parser.ArithmeticIfStatementContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_ifStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIfStatement" ):
listener.enterIfStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIfStatement" ):
listener.exitIfStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIfStatement" ):
return visitor.visitIfStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def ifStatement(self):
localctx = Fortran77Parser.IfStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 152, self.RULE_ifStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 923
self.match(Fortran77Parser.IF)
self.state = 924
self.match(Fortran77Parser.LPAREN)
self.state = 925
self.logicalExpression()
self.state = 926
self.match(Fortran77Parser.RPAREN)
self.state = 930
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,70,self._ctx)
if la_ == 1:
self.state = 927
self.blockIfStatement()
pass
elif la_ == 2:
self.state = 928
self.logicalIfStatement()
pass
elif la_ == 3:
self.state = 929
self.arithmeticIfStatement()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ArithmeticIfStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def lblRef(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.LblRefContext)
else:
return self.getTypedRuleContext(Fortran77Parser.LblRefContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.COMMA)
else:
return self.getToken(Fortran77Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_arithmeticIfStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterArithmeticIfStatement" ):
listener.enterArithmeticIfStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitArithmeticIfStatement" ):
listener.exitArithmeticIfStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitArithmeticIfStatement" ):
return visitor.visitArithmeticIfStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def arithmeticIfStatement(self):
localctx = Fortran77Parser.ArithmeticIfStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 154, self.RULE_arithmeticIfStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 932
self.lblRef()
self.state = 933
self.match(Fortran77Parser.COMMA)
self.state = 934
self.lblRef()
self.state = 935
self.match(Fortran77Parser.COMMA)
self.state = 936
self.lblRef()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class LogicalIfStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def executableStatement(self):
return self.getTypedRuleContext(Fortran77Parser.ExecutableStatementContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_logicalIfStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLogicalIfStatement" ):
listener.enterLogicalIfStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLogicalIfStatement" ):
listener.exitLogicalIfStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLogicalIfStatement" ):
return visitor.visitLogicalIfStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def logicalIfStatement(self):
localctx = Fortran77Parser.LogicalIfStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 156, self.RULE_logicalIfStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 938
self.executableStatement()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class BlockIfStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def firstIfBlock(self):
return self.getTypedRuleContext(Fortran77Parser.FirstIfBlockContext,0)
[docs]
def endIfStatement(self):
return self.getTypedRuleContext(Fortran77Parser.EndIfStatementContext,0)
[docs]
def elseIfStatement(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.ElseIfStatementContext)
else:
return self.getTypedRuleContext(Fortran77Parser.ElseIfStatementContext,i)
[docs]
def elseStatement(self):
return self.getTypedRuleContext(Fortran77Parser.ElseStatementContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_blockIfStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterBlockIfStatement" ):
listener.enterBlockIfStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitBlockIfStatement" ):
listener.exitBlockIfStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitBlockIfStatement" ):
return visitor.visitBlockIfStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def blockIfStatement(self):
localctx = Fortran77Parser.BlockIfStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 158, self.RULE_blockIfStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 940
self.firstIfBlock()
self.state = 944
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,71,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 941
self.elseIfStatement()
self.state = 946
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,71,self._ctx)
self.state = 948
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.ELSE:
self.state = 947
self.elseStatement()
self.state = 950
self.endIfStatement()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class FirstIfBlockContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def THEN(self):
return self.getToken(Fortran77Parser.THEN, 0)
[docs]
def EOL(self):
return self.getToken(Fortran77Parser.EOL, 0)
[docs]
def wholeStatement(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.WholeStatementContext)
else:
return self.getTypedRuleContext(Fortran77Parser.WholeStatementContext,i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_firstIfBlock
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterFirstIfBlock" ):
listener.enterFirstIfBlock(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitFirstIfBlock" ):
listener.exitFirstIfBlock(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFirstIfBlock" ):
return visitor.visitFirstIfBlock(self)
else:
return visitor.visitChildren(self)
[docs]
def firstIfBlock(self):
localctx = Fortran77Parser.FirstIfBlockContext(self, self._ctx, self.state)
self.enterRule(localctx, 160, self.RULE_firstIfBlock)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 952
self.match(Fortran77Parser.THEN)
self.state = 954
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.EOL:
self.state = 953
self.match(Fortran77Parser.EOL)
self.state = 959
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.COMMENT:
self.state = 956
self.commentStatement()
self.state = 961
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 969
self._errHandler.sync(self)
_la = self._input.LA(1)
while True:
self.state = 962
self.wholeStatement()
self.state = 966
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.COMMENT:
self.state = 963
self.commentStatement()
self.state = 968
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 971
self._errHandler.sync(self)
_la = self._input.LA(1)
if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Fortran77Parser.ENTRY) | (1 << Fortran77Parser.DIMENSION) | (1 << Fortran77Parser.REAL) | (1 << Fortran77Parser.EQUIVALENCE) | (1 << Fortran77Parser.COMMON) | (1 << Fortran77Parser.POINTER) | (1 << Fortran77Parser.IMPLICIT) | (1 << Fortran77Parser.CHARACTER) | (1 << Fortran77Parser.PARAMETER) | (1 << Fortran77Parser.EXTERNAL) | (1 << Fortran77Parser.INTRINSIC) | (1 << Fortran77Parser.SAVE) | (1 << Fortran77Parser.DATA) | (1 << Fortran77Parser.GO) | (1 << Fortran77Parser.GOTO) | (1 << Fortran77Parser.IF) | (1 << Fortran77Parser.DO) | (1 << Fortran77Parser.CONTINUE) | (1 << Fortran77Parser.STOP) | (1 << Fortran77Parser.PAUSE) | (1 << Fortran77Parser.WRITE) | (1 << Fortran77Parser.READ) | (1 << Fortran77Parser.PRINT) | (1 << Fortran77Parser.OPEN) | (1 << Fortran77Parser.LET) | (1 << Fortran77Parser.CALL) | (1 << Fortran77Parser.RETURN) | (1 << Fortran77Parser.CLOSE) | (1 << Fortran77Parser.DOUBLE) | (1 << Fortran77Parser.LABEL))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (Fortran77Parser.INQUIRE - 64)) | (1 << (Fortran77Parser.BACKSPACE - 64)) | (1 << (Fortran77Parser.ENDFILE - 64)) | (1 << (Fortran77Parser.REWIND - 64)) | (1 << (Fortran77Parser.LPAREN - 64)) | (1 << (Fortran77Parser.MINUS - 64)) | (1 << (Fortran77Parser.PLUS - 64)) | (1 << (Fortran77Parser.LNOT - 64)) | (1 << (Fortran77Parser.TRUE - 64)) | (1 << (Fortran77Parser.FALSE - 64)) | (1 << (Fortran77Parser.HOLLERITH - 64)) | (1 << (Fortran77Parser.COMPLEX - 64)) | (1 << (Fortran77Parser.INTEGER - 64)) | (1 << (Fortran77Parser.LOGICAL - 64)) | (1 << (Fortran77Parser.SCON - 64)) | (1 << (Fortran77Parser.RCON - 64)) | (1 << (Fortran77Parser.ICON - 64)) | (1 << (Fortran77Parser.NAME - 64)))) != 0)):
break
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ElseIfStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def LPAREN(self):
return self.getToken(Fortran77Parser.LPAREN, 0)
[docs]
def logicalExpression(self):
return self.getTypedRuleContext(Fortran77Parser.LogicalExpressionContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran77Parser.RPAREN, 0)
[docs]
def THEN(self):
return self.getToken(Fortran77Parser.THEN, 0)
[docs]
def ELSEIF(self):
return self.getToken(Fortran77Parser.ELSEIF, 0)
[docs]
def EOL(self):
return self.getToken(Fortran77Parser.EOL, 0)
[docs]
def wholeStatement(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.WholeStatementContext)
else:
return self.getTypedRuleContext(Fortran77Parser.WholeStatementContext,i)
[docs]
def ELSE(self):
return self.getToken(Fortran77Parser.ELSE, 0)
[docs]
def IF(self):
return self.getToken(Fortran77Parser.IF, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_elseIfStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterElseIfStatement" ):
listener.enterElseIfStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitElseIfStatement" ):
listener.exitElseIfStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitElseIfStatement" ):
return visitor.visitElseIfStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def elseIfStatement(self):
localctx = Fortran77Parser.ElseIfStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 162, self.RULE_elseIfStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 976
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran77Parser.ELSEIF]:
self.state = 973
self.match(Fortran77Parser.ELSEIF)
pass
elif token in [Fortran77Parser.ELSE]:
self.state = 974
self.match(Fortran77Parser.ELSE)
self.state = 975
self.match(Fortran77Parser.IF)
pass
else:
raise NoViableAltException(self)
self.state = 978
self.match(Fortran77Parser.LPAREN)
self.state = 979
self.logicalExpression()
self.state = 980
self.match(Fortran77Parser.RPAREN)
self.state = 981
self.match(Fortran77Parser.THEN)
self.state = 983
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.EOL:
self.state = 982
self.match(Fortran77Parser.EOL)
self.state = 986
self._errHandler.sync(self)
_la = self._input.LA(1)
while True:
self.state = 985
self.wholeStatement()
self.state = 988
self._errHandler.sync(self)
_la = self._input.LA(1)
if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Fortran77Parser.ENTRY) | (1 << Fortran77Parser.DIMENSION) | (1 << Fortran77Parser.REAL) | (1 << Fortran77Parser.EQUIVALENCE) | (1 << Fortran77Parser.COMMON) | (1 << Fortran77Parser.POINTER) | (1 << Fortran77Parser.IMPLICIT) | (1 << Fortran77Parser.CHARACTER) | (1 << Fortran77Parser.PARAMETER) | (1 << Fortran77Parser.EXTERNAL) | (1 << Fortran77Parser.INTRINSIC) | (1 << Fortran77Parser.SAVE) | (1 << Fortran77Parser.DATA) | (1 << Fortran77Parser.GO) | (1 << Fortran77Parser.GOTO) | (1 << Fortran77Parser.IF) | (1 << Fortran77Parser.DO) | (1 << Fortran77Parser.CONTINUE) | (1 << Fortran77Parser.STOP) | (1 << Fortran77Parser.PAUSE) | (1 << Fortran77Parser.WRITE) | (1 << Fortran77Parser.READ) | (1 << Fortran77Parser.PRINT) | (1 << Fortran77Parser.OPEN) | (1 << Fortran77Parser.LET) | (1 << Fortran77Parser.CALL) | (1 << Fortran77Parser.RETURN) | (1 << Fortran77Parser.CLOSE) | (1 << Fortran77Parser.DOUBLE) | (1 << Fortran77Parser.LABEL))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (Fortran77Parser.INQUIRE - 64)) | (1 << (Fortran77Parser.BACKSPACE - 64)) | (1 << (Fortran77Parser.ENDFILE - 64)) | (1 << (Fortran77Parser.REWIND - 64)) | (1 << (Fortran77Parser.LPAREN - 64)) | (1 << (Fortran77Parser.MINUS - 64)) | (1 << (Fortran77Parser.PLUS - 64)) | (1 << (Fortran77Parser.LNOT - 64)) | (1 << (Fortran77Parser.TRUE - 64)) | (1 << (Fortran77Parser.FALSE - 64)) | (1 << (Fortran77Parser.HOLLERITH - 64)) | (1 << (Fortran77Parser.COMPLEX - 64)) | (1 << (Fortran77Parser.INTEGER - 64)) | (1 << (Fortran77Parser.LOGICAL - 64)) | (1 << (Fortran77Parser.SCON - 64)) | (1 << (Fortran77Parser.RCON - 64)) | (1 << (Fortran77Parser.ICON - 64)) | (1 << (Fortran77Parser.NAME - 64)))) != 0)):
break
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ElseStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ELSE(self):
return self.getToken(Fortran77Parser.ELSE, 0)
[docs]
def EOL(self):
return self.getToken(Fortran77Parser.EOL, 0)
[docs]
def wholeStatement(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.WholeStatementContext)
else:
return self.getTypedRuleContext(Fortran77Parser.WholeStatementContext,i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_elseStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterElseStatement" ):
listener.enterElseStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitElseStatement" ):
listener.exitElseStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitElseStatement" ):
return visitor.visitElseStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def elseStatement(self):
localctx = Fortran77Parser.ElseStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 164, self.RULE_elseStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 990
self.match(Fortran77Parser.ELSE)
self.state = 992
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.EOL:
self.state = 991
self.match(Fortran77Parser.EOL)
self.state = 997
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.COMMENT:
self.state = 994
self.commentStatement()
self.state = 999
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 1007
self._errHandler.sync(self)
_la = self._input.LA(1)
while True:
self.state = 1000
self.wholeStatement()
self.state = 1004
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.COMMENT:
self.state = 1001
self.commentStatement()
self.state = 1006
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 1009
self._errHandler.sync(self)
_la = self._input.LA(1)
if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Fortran77Parser.ENTRY) | (1 << Fortran77Parser.DIMENSION) | (1 << Fortran77Parser.REAL) | (1 << Fortran77Parser.EQUIVALENCE) | (1 << Fortran77Parser.COMMON) | (1 << Fortran77Parser.POINTER) | (1 << Fortran77Parser.IMPLICIT) | (1 << Fortran77Parser.CHARACTER) | (1 << Fortran77Parser.PARAMETER) | (1 << Fortran77Parser.EXTERNAL) | (1 << Fortran77Parser.INTRINSIC) | (1 << Fortran77Parser.SAVE) | (1 << Fortran77Parser.DATA) | (1 << Fortran77Parser.GO) | (1 << Fortran77Parser.GOTO) | (1 << Fortran77Parser.IF) | (1 << Fortran77Parser.DO) | (1 << Fortran77Parser.CONTINUE) | (1 << Fortran77Parser.STOP) | (1 << Fortran77Parser.PAUSE) | (1 << Fortran77Parser.WRITE) | (1 << Fortran77Parser.READ) | (1 << Fortran77Parser.PRINT) | (1 << Fortran77Parser.OPEN) | (1 << Fortran77Parser.LET) | (1 << Fortran77Parser.CALL) | (1 << Fortran77Parser.RETURN) | (1 << Fortran77Parser.CLOSE) | (1 << Fortran77Parser.DOUBLE) | (1 << Fortran77Parser.LABEL))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (Fortran77Parser.INQUIRE - 64)) | (1 << (Fortran77Parser.BACKSPACE - 64)) | (1 << (Fortran77Parser.ENDFILE - 64)) | (1 << (Fortran77Parser.REWIND - 64)) | (1 << (Fortran77Parser.LPAREN - 64)) | (1 << (Fortran77Parser.MINUS - 64)) | (1 << (Fortran77Parser.PLUS - 64)) | (1 << (Fortran77Parser.LNOT - 64)) | (1 << (Fortran77Parser.TRUE - 64)) | (1 << (Fortran77Parser.FALSE - 64)) | (1 << (Fortran77Parser.HOLLERITH - 64)) | (1 << (Fortran77Parser.COMPLEX - 64)) | (1 << (Fortran77Parser.INTEGER - 64)) | (1 << (Fortran77Parser.LOGICAL - 64)) | (1 << (Fortran77Parser.SCON - 64)) | (1 << (Fortran77Parser.RCON - 64)) | (1 << (Fortran77Parser.ICON - 64)) | (1 << (Fortran77Parser.NAME - 64)))) != 0)):
break
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class EndIfStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ENDIF(self):
return self.getToken(Fortran77Parser.ENDIF, 0)
[docs]
def END(self):
return self.getToken(Fortran77Parser.END, 0)
[docs]
def IF(self):
return self.getToken(Fortran77Parser.IF, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_endIfStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEndIfStatement" ):
listener.enterEndIfStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEndIfStatement" ):
listener.exitEndIfStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEndIfStatement" ):
return visitor.visitEndIfStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def endIfStatement(self):
localctx = Fortran77Parser.EndIfStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 166, self.RULE_endIfStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1014
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran77Parser.ENDIF]:
self.state = 1011
self.match(Fortran77Parser.ENDIF)
pass
elif token in [Fortran77Parser.END]:
self.state = 1012
self.match(Fortran77Parser.END)
self.state = 1013
self.match(Fortran77Parser.IF)
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class DoStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def DO(self):
return self.getToken(Fortran77Parser.DO, 0)
[docs]
def doWithLabel(self):
return self.getTypedRuleContext(Fortran77Parser.DoWithLabelContext,0)
[docs]
def doWithEndDo(self):
return self.getTypedRuleContext(Fortran77Parser.DoWithEndDoContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_doStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDoStatement" ):
listener.enterDoStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDoStatement" ):
listener.exitDoStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDoStatement" ):
return visitor.visitDoStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def doStatement(self):
localctx = Fortran77Parser.DoStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 168, self.RULE_doStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1016
self.match(Fortran77Parser.DO)
self.state = 1019
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran77Parser.ICON]:
self.state = 1017
self.doWithLabel()
pass
elif token in [Fortran77Parser.NAME]:
self.state = 1018
self.doWithEndDo()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class DoVarArgsContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def variableName(self):
return self.getTypedRuleContext(Fortran77Parser.VariableNameContext,0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran77Parser.ASSIGN, 0)
[docs]
def intRealDpExpr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.IntRealDpExprContext)
else:
return self.getTypedRuleContext(Fortran77Parser.IntRealDpExprContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.COMMA)
else:
return self.getToken(Fortran77Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_doVarArgs
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDoVarArgs" ):
listener.enterDoVarArgs(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDoVarArgs" ):
listener.exitDoVarArgs(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDoVarArgs" ):
return visitor.visitDoVarArgs(self)
else:
return visitor.visitChildren(self)
[docs]
def doVarArgs(self):
localctx = Fortran77Parser.DoVarArgsContext(self, self._ctx, self.state)
self.enterRule(localctx, 170, self.RULE_doVarArgs)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1021
self.variableName()
self.state = 1022
self.match(Fortran77Parser.ASSIGN)
self.state = 1023
self.intRealDpExpr()
self.state = 1024
self.match(Fortran77Parser.COMMA)
self.state = 1025
self.intRealDpExpr()
self.state = 1028
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.COMMA:
self.state = 1026
self.match(Fortran77Parser.COMMA)
self.state = 1027
self.intRealDpExpr()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class DoWithLabelContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def lblRef(self):
return self.getTypedRuleContext(Fortran77Parser.LblRefContext,0)
[docs]
def doVarArgs(self):
return self.getTypedRuleContext(Fortran77Parser.DoVarArgsContext,0)
[docs]
def doBody(self):
return self.getTypedRuleContext(Fortran77Parser.DoBodyContext,0)
[docs]
def continueStatement(self):
return self.getTypedRuleContext(Fortran77Parser.ContinueStatementContext,0)
[docs]
def COMMA(self):
return self.getToken(Fortran77Parser.COMMA, 0)
[docs]
def EOL(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.EOL)
else:
return self.getToken(Fortran77Parser.EOL, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_doWithLabel
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDoWithLabel" ):
listener.enterDoWithLabel(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDoWithLabel" ):
listener.exitDoWithLabel(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDoWithLabel" ):
return visitor.visitDoWithLabel(self)
else:
return visitor.visitChildren(self)
[docs]
def doWithLabel(self):
localctx = Fortran77Parser.DoWithLabelContext(self, self._ctx, self.state)
self.enterRule(localctx, 172, self.RULE_doWithLabel)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1030
self.lblRef()
self.state = 1032
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.COMMA:
self.state = 1031
self.match(Fortran77Parser.COMMA)
self.state = 1034
self.doVarArgs()
self.state = 1036
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.EOL:
self.state = 1035
self.match(Fortran77Parser.EOL)
self.state = 1038
self.doBody()
self.state = 1040
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.EOL:
self.state = 1039
self.match(Fortran77Parser.EOL)
self.state = 1042
self.continueStatement()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class DoBodyContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def wholeStatement(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.WholeStatementContext)
else:
return self.getTypedRuleContext(Fortran77Parser.WholeStatementContext,i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_doBody
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDoBody" ):
listener.enterDoBody(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDoBody" ):
listener.exitDoBody(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDoBody" ):
return visitor.visitDoBody(self)
else:
return visitor.visitChildren(self)
[docs]
def doBody(self):
localctx = Fortran77Parser.DoBodyContext(self, self._ctx, self.state)
self.enterRule(localctx, 174, self.RULE_doBody)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1045
self._errHandler.sync(self)
_alt = 1
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 1044
self.wholeStatement()
else:
raise NoViableAltException(self)
self.state = 1047
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,90,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class DoWithEndDoContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def doVarArgs(self):
return self.getTypedRuleContext(Fortran77Parser.DoVarArgsContext,0)
[docs]
def doBody(self):
return self.getTypedRuleContext(Fortran77Parser.DoBodyContext,0)
[docs]
def enddoStatement(self):
return self.getTypedRuleContext(Fortran77Parser.EnddoStatementContext,0)
[docs]
def EOL(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.EOL)
else:
return self.getToken(Fortran77Parser.EOL, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_doWithEndDo
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDoWithEndDo" ):
listener.enterDoWithEndDo(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDoWithEndDo" ):
listener.exitDoWithEndDo(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDoWithEndDo" ):
return visitor.visitDoWithEndDo(self)
else:
return visitor.visitChildren(self)
[docs]
def doWithEndDo(self):
localctx = Fortran77Parser.DoWithEndDoContext(self, self._ctx, self.state)
self.enterRule(localctx, 176, self.RULE_doWithEndDo)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1049
self.doVarArgs()
self.state = 1051
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.EOL:
self.state = 1050
self.match(Fortran77Parser.EOL)
self.state = 1053
self.doBody()
self.state = 1055
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.EOL:
self.state = 1054
self.match(Fortran77Parser.EOL)
self.state = 1057
self.enddoStatement()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class EnddoStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ENDDO(self):
return self.getToken(Fortran77Parser.ENDDO, 0)
[docs]
def END(self):
return self.getToken(Fortran77Parser.END, 0)
[docs]
def DO(self):
return self.getToken(Fortran77Parser.DO, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_enddoStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEnddoStatement" ):
listener.enterEnddoStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEnddoStatement" ):
listener.exitEnddoStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEnddoStatement" ):
return visitor.visitEnddoStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def enddoStatement(self):
localctx = Fortran77Parser.EnddoStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 178, self.RULE_enddoStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1062
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran77Parser.ENDDO]:
self.state = 1059
self.match(Fortran77Parser.ENDDO)
pass
elif token in [Fortran77Parser.END]:
self.state = 1060
self.match(Fortran77Parser.END)
self.state = 1061
self.match(Fortran77Parser.DO)
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ContinueStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def CONTINUE(self):
return self.getToken(Fortran77Parser.CONTINUE, 0)
[docs]
def lblRef(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.LblRefContext)
else:
return self.getTypedRuleContext(Fortran77Parser.LblRefContext,i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_continueStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterContinueStatement" ):
listener.enterContinueStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitContinueStatement" ):
listener.exitContinueStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitContinueStatement" ):
return visitor.visitContinueStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def continueStatement(self):
localctx = Fortran77Parser.ContinueStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 180, self.RULE_continueStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1067
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.ICON:
self.state = 1064
self.lblRef()
self.state = 1069
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 1070
self.match(Fortran77Parser.CONTINUE)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class StopStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def STOP(self):
return self.getToken(Fortran77Parser.STOP, 0)
[docs]
def ICON(self):
return self.getToken(Fortran77Parser.ICON, 0)
[docs]
def HOLLERITH(self):
return self.getToken(Fortran77Parser.HOLLERITH, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_stopStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterStopStatement" ):
listener.enterStopStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitStopStatement" ):
listener.exitStopStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitStopStatement" ):
return visitor.visitStopStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def stopStatement(self):
localctx = Fortran77Parser.StopStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 182, self.RULE_stopStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1072
self.match(Fortran77Parser.STOP)
self.state = 1074
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.HOLLERITH or _la==Fortran77Parser.ICON:
self.state = 1073
_la = self._input.LA(1)
if not(_la==Fortran77Parser.HOLLERITH or _la==Fortran77Parser.ICON):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class PauseStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def PAUSE(self):
return self.getToken(Fortran77Parser.PAUSE, 0)
[docs]
def ICON(self):
return self.getToken(Fortran77Parser.ICON, 0)
[docs]
def HOLLERITH(self):
return self.getToken(Fortran77Parser.HOLLERITH, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_pauseStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPauseStatement" ):
listener.enterPauseStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPauseStatement" ):
listener.exitPauseStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPauseStatement" ):
return visitor.visitPauseStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def pauseStatement(self):
localctx = Fortran77Parser.PauseStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 184, self.RULE_pauseStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1076
self.match(Fortran77Parser.PAUSE)
self.state = 1077
_la = self._input.LA(1)
if not(_la==Fortran77Parser.HOLLERITH or _la==Fortran77Parser.ICON):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class WriteStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def WRITE(self):
return self.getToken(Fortran77Parser.WRITE, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran77Parser.LPAREN, 0)
[docs]
def controlInfoList(self):
return self.getTypedRuleContext(Fortran77Parser.ControlInfoListContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran77Parser.RPAREN, 0)
[docs]
def ioList(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.IoListContext)
else:
return self.getTypedRuleContext(Fortran77Parser.IoListContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.COMMA)
else:
return self.getToken(Fortran77Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_writeStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterWriteStatement" ):
listener.enterWriteStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitWriteStatement" ):
listener.exitWriteStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitWriteStatement" ):
return visitor.visitWriteStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def writeStatement(self):
localctx = Fortran77Parser.WriteStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 186, self.RULE_writeStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1079
self.match(Fortran77Parser.WRITE)
self.state = 1080
self.match(Fortran77Parser.LPAREN)
self.state = 1081
self.controlInfoList()
self.state = 1082
self.match(Fortran77Parser.RPAREN)
self.state = 1091
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.REAL or ((((_la - 69)) & ~0x3f) == 0 and ((1 << (_la - 69)) & ((1 << (Fortran77Parser.COMMA - 69)) | (1 << (Fortran77Parser.LPAREN - 69)) | (1 << (Fortran77Parser.MINUS - 69)) | (1 << (Fortran77Parser.PLUS - 69)) | (1 << (Fortran77Parser.LNOT - 69)) | (1 << (Fortran77Parser.TRUE - 69)) | (1 << (Fortran77Parser.FALSE - 69)) | (1 << (Fortran77Parser.HOLLERITH - 69)) | (1 << (Fortran77Parser.SCON - 69)) | (1 << (Fortran77Parser.RCON - 69)) | (1 << (Fortran77Parser.ICON - 69)) | (1 << (Fortran77Parser.NAME - 69)))) != 0):
self.state = 1087
self._errHandler.sync(self)
_la = self._input.LA(1)
while True:
self.state = 1084
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.COMMA:
self.state = 1083
self.match(Fortran77Parser.COMMA)
self.state = 1086
self.ioList()
self.state = 1089
self._errHandler.sync(self)
_la = self._input.LA(1)
if not (_la==Fortran77Parser.REAL or ((((_la - 69)) & ~0x3f) == 0 and ((1 << (_la - 69)) & ((1 << (Fortran77Parser.COMMA - 69)) | (1 << (Fortran77Parser.LPAREN - 69)) | (1 << (Fortran77Parser.MINUS - 69)) | (1 << (Fortran77Parser.PLUS - 69)) | (1 << (Fortran77Parser.LNOT - 69)) | (1 << (Fortran77Parser.TRUE - 69)) | (1 << (Fortran77Parser.FALSE - 69)) | (1 << (Fortran77Parser.HOLLERITH - 69)) | (1 << (Fortran77Parser.SCON - 69)) | (1 << (Fortran77Parser.RCON - 69)) | (1 << (Fortran77Parser.ICON - 69)) | (1 << (Fortran77Parser.NAME - 69)))) != 0)):
break
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ReadStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def READ(self):
return self.getToken(Fortran77Parser.READ, 0)
[docs]
def formatIdentifier(self):
return self.getTypedRuleContext(Fortran77Parser.FormatIdentifierContext,0)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.COMMA)
else:
return self.getToken(Fortran77Parser.COMMA, i)
[docs]
def ioList(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.IoListContext)
else:
return self.getTypedRuleContext(Fortran77Parser.IoListContext,i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_readStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterReadStatement" ):
listener.enterReadStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitReadStatement" ):
listener.exitReadStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitReadStatement" ):
return visitor.visitReadStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def readStatement(self):
localctx = Fortran77Parser.ReadStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 188, self.RULE_readStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1093
self.match(Fortran77Parser.READ)
self.state = 1094
self.formatIdentifier()
self.state = 1101
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.COMMA:
self.state = 1097
self._errHandler.sync(self)
_la = self._input.LA(1)
while True:
self.state = 1095
self.match(Fortran77Parser.COMMA)
self.state = 1096
self.ioList()
self.state = 1099
self._errHandler.sync(self)
_la = self._input.LA(1)
if not (_la==Fortran77Parser.COMMA):
break
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class PrintStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def PRINT(self):
return self.getToken(Fortran77Parser.PRINT, 0)
[docs]
def formatIdentifier(self):
return self.getTypedRuleContext(Fortran77Parser.FormatIdentifierContext,0)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.COMMA)
else:
return self.getToken(Fortran77Parser.COMMA, i)
[docs]
def ioList(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.IoListContext)
else:
return self.getTypedRuleContext(Fortran77Parser.IoListContext,i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_printStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPrintStatement" ):
listener.enterPrintStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPrintStatement" ):
listener.exitPrintStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPrintStatement" ):
return visitor.visitPrintStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def printStatement(self):
localctx = Fortran77Parser.PrintStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 190, self.RULE_printStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1103
self.match(Fortran77Parser.PRINT)
self.state = 1104
self.formatIdentifier()
self.state = 1111
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.COMMA:
self.state = 1107
self._errHandler.sync(self)
_la = self._input.LA(1)
while True:
self.state = 1105
self.match(Fortran77Parser.COMMA)
self.state = 1106
self.ioList()
self.state = 1109
self._errHandler.sync(self)
_la = self._input.LA(1)
if not (_la==Fortran77Parser.COMMA):
break
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class AssignmentStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def varRef(self):
return self.getTypedRuleContext(Fortran77Parser.VarRefContext,0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran77Parser.ASSIGN, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran77Parser.ExpressionContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_assignmentStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAssignmentStatement" ):
listener.enterAssignmentStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAssignmentStatement" ):
listener.exitAssignmentStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAssignmentStatement" ):
return visitor.visitAssignmentStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def assignmentStatement(self):
localctx = Fortran77Parser.AssignmentStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 192, self.RULE_assignmentStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1113
self.varRef()
self.state = 1114
self.match(Fortran77Parser.ASSIGN)
self.state = 1115
self.expression()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ControlInfoListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def controlInfoListItem(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.ControlInfoListItemContext)
else:
return self.getTypedRuleContext(Fortran77Parser.ControlInfoListItemContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.COMMA)
else:
return self.getToken(Fortran77Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_controlInfoList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterControlInfoList" ):
listener.enterControlInfoList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitControlInfoList" ):
listener.exitControlInfoList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitControlInfoList" ):
return visitor.visitControlInfoList(self)
else:
return visitor.visitChildren(self)
[docs]
def controlInfoList(self):
localctx = Fortran77Parser.ControlInfoListContext(self, self._ctx, self.state)
self.enterRule(localctx, 194, self.RULE_controlInfoList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1117
self.controlInfoListItem()
self.state = 1122
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.COMMA:
self.state = 1118
self.match(Fortran77Parser.COMMA)
self.state = 1119
self.controlInfoListItem()
self.state = 1124
self._errHandler.sync(self)
_la = self._input.LA(1)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ControlErrSpecContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def controlErr(self):
return self.getTypedRuleContext(Fortran77Parser.ControlErrContext,0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran77Parser.ASSIGN, 0)
[docs]
def lblRef(self):
return self.getTypedRuleContext(Fortran77Parser.LblRefContext,0)
[docs]
def NAME(self):
return self.getToken(Fortran77Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_controlErrSpec
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterControlErrSpec" ):
listener.enterControlErrSpec(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitControlErrSpec" ):
listener.exitControlErrSpec(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitControlErrSpec" ):
return visitor.visitControlErrSpec(self)
else:
return visitor.visitChildren(self)
[docs]
def controlErrSpec(self):
localctx = Fortran77Parser.ControlErrSpecContext(self, self._ctx, self.state)
self.enterRule(localctx, 196, self.RULE_controlErrSpec)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1125
self.controlErr()
self.state = 1126
self.match(Fortran77Parser.ASSIGN)
self.state = 1129
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran77Parser.ICON]:
self.state = 1127
self.lblRef()
pass
elif token in [Fortran77Parser.NAME]:
self.state = 1128
self.match(Fortran77Parser.NAME)
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ControlInfoListItemContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def unitIdentifier(self):
return self.getTypedRuleContext(Fortran77Parser.UnitIdentifierContext,0)
[docs]
def HOLLERITH(self):
return self.getToken(Fortran77Parser.HOLLERITH, 0)
[docs]
def SCON(self):
return self.getToken(Fortran77Parser.SCON, 0)
[docs]
def controlFmt(self):
return self.getTypedRuleContext(Fortran77Parser.ControlFmtContext,0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran77Parser.ASSIGN, 0)
[docs]
def formatIdentifier(self):
return self.getTypedRuleContext(Fortran77Parser.FormatIdentifierContext,0)
[docs]
def controlUnit(self):
return self.getTypedRuleContext(Fortran77Parser.ControlUnitContext,0)
[docs]
def controlRec(self):
return self.getTypedRuleContext(Fortran77Parser.ControlRecContext,0)
[docs]
def integerExpr(self):
return self.getTypedRuleContext(Fortran77Parser.IntegerExprContext,0)
[docs]
def controlEnd(self):
return self.getTypedRuleContext(Fortran77Parser.ControlEndContext,0)
[docs]
def lblRef(self):
return self.getTypedRuleContext(Fortran77Parser.LblRefContext,0)
[docs]
def controlErrSpec(self):
return self.getTypedRuleContext(Fortran77Parser.ControlErrSpecContext,0)
[docs]
def controlIostat(self):
return self.getTypedRuleContext(Fortran77Parser.ControlIostatContext,0)
[docs]
def varRef(self):
return self.getTypedRuleContext(Fortran77Parser.VarRefContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_controlInfoListItem
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterControlInfoListItem" ):
listener.enterControlInfoListItem(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitControlInfoListItem" ):
listener.exitControlInfoListItem(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitControlInfoListItem" ):
return visitor.visitControlInfoListItem(self)
else:
return visitor.visitChildren(self)
[docs]
def controlInfoListItem(self):
localctx = Fortran77Parser.ControlInfoListItemContext(self, self._ctx, self.state)
self.enterRule(localctx, 198, self.RULE_controlInfoListItem)
self._la = 0 # Token type
try:
self.state = 1154
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,105,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1131
self.unitIdentifier()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1132
_la = self._input.LA(1)
if not(_la==Fortran77Parser.HOLLERITH or _la==Fortran77Parser.SCON):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 1133
self.controlFmt()
self.state = 1134
self.match(Fortran77Parser.ASSIGN)
self.state = 1135
self.formatIdentifier()
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 1137
self.controlUnit()
self.state = 1138
self.match(Fortran77Parser.ASSIGN)
self.state = 1139
self.unitIdentifier()
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 1141
self.controlRec()
self.state = 1142
self.match(Fortran77Parser.ASSIGN)
self.state = 1143
self.integerExpr()
pass
elif la_ == 6:
self.enterOuterAlt(localctx, 6)
self.state = 1145
self.controlEnd()
self.state = 1146
self.match(Fortran77Parser.ASSIGN)
self.state = 1147
self.lblRef()
pass
elif la_ == 7:
self.enterOuterAlt(localctx, 7)
self.state = 1149
self.controlErrSpec()
pass
elif la_ == 8:
self.enterOuterAlt(localctx, 8)
self.state = 1150
self.controlIostat()
self.state = 1151
self.match(Fortran77Parser.ASSIGN)
self.state = 1152
self.varRef()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class IoListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ioListItem(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.IoListItemContext)
else:
return self.getTypedRuleContext(Fortran77Parser.IoListItemContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.COMMA)
else:
return self.getToken(Fortran77Parser.COMMA, i)
[docs]
def NAME(self):
return self.getToken(Fortran77Parser.NAME, 0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran77Parser.ASSIGN, 0)
[docs]
def ioList(self):
return self.getTypedRuleContext(Fortran77Parser.IoListContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_ioList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIoList" ):
listener.enterIoList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIoList" ):
listener.exitIoList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIoList" ):
return visitor.visitIoList(self)
else:
return visitor.visitChildren(self)
[docs]
def ioList(self):
localctx = Fortran77Parser.IoListContext(self, self._ctx, self.state)
self.enterRule(localctx, 200, self.RULE_ioList)
try:
self.state = 1172
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,106,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1156
self.ioListItem()
self.state = 1157
self.match(Fortran77Parser.COMMA)
self.state = 1158
self.match(Fortran77Parser.NAME)
self.state = 1159
self.match(Fortran77Parser.ASSIGN)
self.state = 1161
self.ioListItem()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1163
self.ioListItem()
self.state = 1164
self.match(Fortran77Parser.COMMA)
self.state = 1165
self.ioListItem()
self.state = 1167
self.ioListItem()
self.state = 1168
self.match(Fortran77Parser.COMMA)
self.state = 1169
self.ioList()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 1171
self.ioListItem()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class IoListItemContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ioImpliedDoList(self):
return self.getTypedRuleContext(Fortran77Parser.IoImpliedDoListContext,0)
[docs]
def LPAREN(self):
return self.getToken(Fortran77Parser.LPAREN, 0)
[docs]
def ioList(self):
return self.getTypedRuleContext(Fortran77Parser.IoListContext,0)
[docs]
def COMMA(self):
return self.getToken(Fortran77Parser.COMMA, 0)
[docs]
def NAME(self):
return self.getToken(Fortran77Parser.NAME, 0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran77Parser.ASSIGN, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran77Parser.ExpressionContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_ioListItem
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIoListItem" ):
listener.enterIoListItem(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIoListItem" ):
listener.exitIoListItem(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIoListItem" ):
return visitor.visitIoListItem(self)
else:
return visitor.visitChildren(self)
[docs]
def ioListItem(self):
localctx = Fortran77Parser.IoListItemContext(self, self._ctx, self.state)
self.enterRule(localctx, 202, self.RULE_ioListItem)
try:
self.state = 1183
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,107,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1174
self.match(Fortran77Parser.LPAREN)
self.state = 1175
self.ioList()
self.state = 1176
self.match(Fortran77Parser.COMMA)
self.state = 1177
self.match(Fortran77Parser.NAME)
self.state = 1178
self.match(Fortran77Parser.ASSIGN)
self.state = 1180
self.ioImpliedDoList()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1182
self.expression()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class IoImpliedDoListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def LPAREN(self):
return self.getToken(Fortran77Parser.LPAREN, 0)
[docs]
def ioList(self):
return self.getTypedRuleContext(Fortran77Parser.IoListContext,0)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.COMMA)
else:
return self.getToken(Fortran77Parser.COMMA, i)
[docs]
def NAME(self):
return self.getToken(Fortran77Parser.NAME, 0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran77Parser.ASSIGN, 0)
[docs]
def intRealDpExpr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.IntRealDpExprContext)
else:
return self.getTypedRuleContext(Fortran77Parser.IntRealDpExprContext,i)
[docs]
def RPAREN(self):
return self.getToken(Fortran77Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_ioImpliedDoList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIoImpliedDoList" ):
listener.enterIoImpliedDoList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIoImpliedDoList" ):
listener.exitIoImpliedDoList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIoImpliedDoList" ):
return visitor.visitIoImpliedDoList(self)
else:
return visitor.visitChildren(self)
[docs]
def ioImpliedDoList(self):
localctx = Fortran77Parser.IoImpliedDoListContext(self, self._ctx, self.state)
self.enterRule(localctx, 204, self.RULE_ioImpliedDoList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1185
self.match(Fortran77Parser.LPAREN)
self.state = 1186
self.ioList()
self.state = 1187
self.match(Fortran77Parser.COMMA)
self.state = 1188
self.match(Fortran77Parser.NAME)
self.state = 1189
self.match(Fortran77Parser.ASSIGN)
self.state = 1190
self.intRealDpExpr()
self.state = 1191
self.match(Fortran77Parser.COMMA)
self.state = 1192
self.intRealDpExpr()
self.state = 1195
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.COMMA:
self.state = 1193
self.match(Fortran77Parser.COMMA)
self.state = 1194
self.intRealDpExpr()
self.state = 1197
self.match(Fortran77Parser.RPAREN)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class OpenStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def OPEN(self):
return self.getToken(Fortran77Parser.OPEN, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran77Parser.LPAREN, 0)
[docs]
def openControl(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.OpenControlContext)
else:
return self.getTypedRuleContext(Fortran77Parser.OpenControlContext,i)
[docs]
def RPAREN(self):
return self.getToken(Fortran77Parser.RPAREN, 0)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.COMMA)
else:
return self.getToken(Fortran77Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_openStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterOpenStatement" ):
listener.enterOpenStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitOpenStatement" ):
listener.exitOpenStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitOpenStatement" ):
return visitor.visitOpenStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def openStatement(self):
localctx = Fortran77Parser.OpenStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 206, self.RULE_openStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1199
self.match(Fortran77Parser.OPEN)
self.state = 1200
self.match(Fortran77Parser.LPAREN)
self.state = 1201
self.openControl()
self.state = 1206
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.COMMA:
self.state = 1202
self.match(Fortran77Parser.COMMA)
self.state = 1203
self.openControl()
self.state = 1208
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 1209
self.match(Fortran77Parser.RPAREN)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class OpenControlContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def unitIdentifier(self):
return self.getTypedRuleContext(Fortran77Parser.UnitIdentifierContext,0)
[docs]
def controlUnit(self):
return self.getTypedRuleContext(Fortran77Parser.ControlUnitContext,0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran77Parser.ASSIGN, 0)
[docs]
def controlErrSpec(self):
return self.getTypedRuleContext(Fortran77Parser.ControlErrSpecContext,0)
[docs]
def controlFile(self):
return self.getTypedRuleContext(Fortran77Parser.ControlFileContext,0)
[docs]
def characterExpression(self):
return self.getTypedRuleContext(Fortran77Parser.CharacterExpressionContext,0)
[docs]
def controlStatus(self):
return self.getTypedRuleContext(Fortran77Parser.ControlStatusContext,0)
[docs]
def controlAccess(self):
return self.getTypedRuleContext(Fortran77Parser.ControlAccessContext,0)
[docs]
def controlPosition(self):
return self.getTypedRuleContext(Fortran77Parser.ControlPositionContext,0)
[docs]
def controlForm(self):
return self.getTypedRuleContext(Fortran77Parser.ControlFormContext,0)
[docs]
def controlRecl(self):
return self.getTypedRuleContext(Fortran77Parser.ControlReclContext,0)
[docs]
def integerExpr(self):
return self.getTypedRuleContext(Fortran77Parser.IntegerExprContext,0)
[docs]
def controlBlank(self):
return self.getTypedRuleContext(Fortran77Parser.ControlBlankContext,0)
[docs]
def controlIostat(self):
return self.getTypedRuleContext(Fortran77Parser.ControlIostatContext,0)
[docs]
def varRef(self):
return self.getTypedRuleContext(Fortran77Parser.VarRefContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_openControl
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterOpenControl" ):
listener.enterOpenControl(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitOpenControl" ):
listener.exitOpenControl(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitOpenControl" ):
return visitor.visitOpenControl(self)
else:
return visitor.visitChildren(self)
[docs]
def openControl(self):
localctx = Fortran77Parser.OpenControlContext(self, self._ctx, self.state)
self.enterRule(localctx, 208, self.RULE_openControl)
try:
self.state = 1248
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran77Parser.LPAREN, Fortran77Parser.MINUS, Fortran77Parser.PLUS, Fortran77Parser.ICON, Fortran77Parser.NAME, Fortran77Parser.STAR]:
self.enterOuterAlt(localctx, 1)
self.state = 1211
self.unitIdentifier()
pass
elif token in [Fortran77Parser.UNIT]:
self.enterOuterAlt(localctx, 2)
self.state = 1212
self.controlUnit()
self.state = 1213
self.match(Fortran77Parser.ASSIGN)
self.state = 1214
self.unitIdentifier()
pass
elif token in [Fortran77Parser.ERR]:
self.enterOuterAlt(localctx, 3)
self.state = 1216
self.controlErrSpec()
pass
elif token in [Fortran77Parser.FILE]:
self.enterOuterAlt(localctx, 4)
self.state = 1217
self.controlFile()
self.state = 1218
self.match(Fortran77Parser.ASSIGN)
self.state = 1219
self.characterExpression()
pass
elif token in [Fortran77Parser.STATUS]:
self.enterOuterAlt(localctx, 5)
self.state = 1221
self.controlStatus()
self.state = 1222
self.match(Fortran77Parser.ASSIGN)
self.state = 1223
self.characterExpression()
pass
elif token in [Fortran77Parser.ACCESS, Fortran77Parser.POSITION]:
self.enterOuterAlt(localctx, 6)
self.state = 1227
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran77Parser.ACCESS]:
self.state = 1225
self.controlAccess()
pass
elif token in [Fortran77Parser.POSITION]:
self.state = 1226
self.controlPosition()
pass
else:
raise NoViableAltException(self)
self.state = 1229
self.match(Fortran77Parser.ASSIGN)
self.state = 1230
self.characterExpression()
pass
elif token in [Fortran77Parser.FORM]:
self.enterOuterAlt(localctx, 7)
self.state = 1232
self.controlForm()
self.state = 1233
self.match(Fortran77Parser.ASSIGN)
self.state = 1234
self.characterExpression()
pass
elif token in [Fortran77Parser.RECL]:
self.enterOuterAlt(localctx, 8)
self.state = 1236
self.controlRecl()
self.state = 1237
self.match(Fortran77Parser.ASSIGN)
self.state = 1238
self.integerExpr()
pass
elif token in [Fortran77Parser.BLANK]:
self.enterOuterAlt(localctx, 9)
self.state = 1240
self.controlBlank()
self.state = 1241
self.match(Fortran77Parser.ASSIGN)
self.state = 1242
self.characterExpression()
pass
elif token in [Fortran77Parser.IOSTART]:
self.enterOuterAlt(localctx, 10)
self.state = 1244
self.controlIostat()
self.state = 1245
self.match(Fortran77Parser.ASSIGN)
self.state = 1246
self.varRef()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ControlFmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def FMT(self):
return self.getToken(Fortran77Parser.FMT, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_controlFmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterControlFmt" ):
listener.enterControlFmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitControlFmt" ):
listener.exitControlFmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitControlFmt" ):
return visitor.visitControlFmt(self)
else:
return visitor.visitChildren(self)
[docs]
def controlFmt(self):
localctx = Fortran77Parser.ControlFmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 210, self.RULE_controlFmt)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1250
self.match(Fortran77Parser.FMT)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ControlUnitContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def UNIT(self):
return self.getToken(Fortran77Parser.UNIT, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_controlUnit
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterControlUnit" ):
listener.enterControlUnit(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitControlUnit" ):
listener.exitControlUnit(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitControlUnit" ):
return visitor.visitControlUnit(self)
else:
return visitor.visitChildren(self)
[docs]
def controlUnit(self):
localctx = Fortran77Parser.ControlUnitContext(self, self._ctx, self.state)
self.enterRule(localctx, 212, self.RULE_controlUnit)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1252
self.match(Fortran77Parser.UNIT)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ControlRecContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def NAME(self):
return self.getToken(Fortran77Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_controlRec
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterControlRec" ):
listener.enterControlRec(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitControlRec" ):
listener.exitControlRec(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitControlRec" ):
return visitor.visitControlRec(self)
else:
return visitor.visitChildren(self)
[docs]
def controlRec(self):
localctx = Fortran77Parser.ControlRecContext(self, self._ctx, self.state)
self.enterRule(localctx, 214, self.RULE_controlRec)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1254
self.match(Fortran77Parser.NAME)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ControlEndContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def END(self):
return self.getToken(Fortran77Parser.END, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_controlEnd
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterControlEnd" ):
listener.enterControlEnd(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitControlEnd" ):
listener.exitControlEnd(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitControlEnd" ):
return visitor.visitControlEnd(self)
else:
return visitor.visitChildren(self)
[docs]
def controlEnd(self):
localctx = Fortran77Parser.ControlEndContext(self, self._ctx, self.state)
self.enterRule(localctx, 216, self.RULE_controlEnd)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1256
self.match(Fortran77Parser.END)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ControlErrContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ERR(self):
return self.getToken(Fortran77Parser.ERR, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_controlErr
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterControlErr" ):
listener.enterControlErr(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitControlErr" ):
listener.exitControlErr(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitControlErr" ):
return visitor.visitControlErr(self)
else:
return visitor.visitChildren(self)
[docs]
def controlErr(self):
localctx = Fortran77Parser.ControlErrContext(self, self._ctx, self.state)
self.enterRule(localctx, 218, self.RULE_controlErr)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1258
self.match(Fortran77Parser.ERR)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ControlIostatContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def IOSTART(self):
return self.getToken(Fortran77Parser.IOSTART, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_controlIostat
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterControlIostat" ):
listener.enterControlIostat(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitControlIostat" ):
listener.exitControlIostat(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitControlIostat" ):
return visitor.visitControlIostat(self)
else:
return visitor.visitChildren(self)
[docs]
def controlIostat(self):
localctx = Fortran77Parser.ControlIostatContext(self, self._ctx, self.state)
self.enterRule(localctx, 220, self.RULE_controlIostat)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1260
self.match(Fortran77Parser.IOSTART)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ControlFileContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def FILE(self):
return self.getToken(Fortran77Parser.FILE, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_controlFile
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterControlFile" ):
listener.enterControlFile(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitControlFile" ):
listener.exitControlFile(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitControlFile" ):
return visitor.visitControlFile(self)
else:
return visitor.visitChildren(self)
[docs]
def controlFile(self):
localctx = Fortran77Parser.ControlFileContext(self, self._ctx, self.state)
self.enterRule(localctx, 222, self.RULE_controlFile)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1262
self.match(Fortran77Parser.FILE)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ControlStatusContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def STATUS(self):
return self.getToken(Fortran77Parser.STATUS, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_controlStatus
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterControlStatus" ):
listener.enterControlStatus(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitControlStatus" ):
listener.exitControlStatus(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitControlStatus" ):
return visitor.visitControlStatus(self)
else:
return visitor.visitChildren(self)
[docs]
def controlStatus(self):
localctx = Fortran77Parser.ControlStatusContext(self, self._ctx, self.state)
self.enterRule(localctx, 224, self.RULE_controlStatus)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1264
self.match(Fortran77Parser.STATUS)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ControlAccessContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ACCESS(self):
return self.getToken(Fortran77Parser.ACCESS, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_controlAccess
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterControlAccess" ):
listener.enterControlAccess(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitControlAccess" ):
listener.exitControlAccess(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitControlAccess" ):
return visitor.visitControlAccess(self)
else:
return visitor.visitChildren(self)
[docs]
def controlAccess(self):
localctx = Fortran77Parser.ControlAccessContext(self, self._ctx, self.state)
self.enterRule(localctx, 226, self.RULE_controlAccess)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1266
self.match(Fortran77Parser.ACCESS)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ControlPositionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def POSITION(self):
return self.getToken(Fortran77Parser.POSITION, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_controlPosition
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterControlPosition" ):
listener.enterControlPosition(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitControlPosition" ):
listener.exitControlPosition(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitControlPosition" ):
return visitor.visitControlPosition(self)
else:
return visitor.visitChildren(self)
[docs]
def controlPosition(self):
localctx = Fortran77Parser.ControlPositionContext(self, self._ctx, self.state)
self.enterRule(localctx, 228, self.RULE_controlPosition)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1268
self.match(Fortran77Parser.POSITION)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ControlFormContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def FORM(self):
return self.getToken(Fortran77Parser.FORM, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_controlForm
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterControlForm" ):
listener.enterControlForm(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitControlForm" ):
listener.exitControlForm(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitControlForm" ):
return visitor.visitControlForm(self)
else:
return visitor.visitChildren(self)
[docs]
class ControlReclContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def RECL(self):
return self.getToken(Fortran77Parser.RECL, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_controlRecl
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterControlRecl" ):
listener.enterControlRecl(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitControlRecl" ):
listener.exitControlRecl(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitControlRecl" ):
return visitor.visitControlRecl(self)
else:
return visitor.visitChildren(self)
[docs]
def controlRecl(self):
localctx = Fortran77Parser.ControlReclContext(self, self._ctx, self.state)
self.enterRule(localctx, 232, self.RULE_controlRecl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1272
self.match(Fortran77Parser.RECL)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ControlBlankContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def BLANK(self):
return self.getToken(Fortran77Parser.BLANK, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_controlBlank
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterControlBlank" ):
listener.enterControlBlank(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitControlBlank" ):
listener.exitControlBlank(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitControlBlank" ):
return visitor.visitControlBlank(self)
else:
return visitor.visitChildren(self)
[docs]
def controlBlank(self):
localctx = Fortran77Parser.ControlBlankContext(self, self._ctx, self.state)
self.enterRule(localctx, 234, self.RULE_controlBlank)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1274
self.match(Fortran77Parser.BLANK)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ControlExistContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def EXIST(self):
return self.getToken(Fortran77Parser.EXIST, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_controlExist
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterControlExist" ):
listener.enterControlExist(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitControlExist" ):
listener.exitControlExist(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitControlExist" ):
return visitor.visitControlExist(self)
else:
return visitor.visitChildren(self)
[docs]
def controlExist(self):
localctx = Fortran77Parser.ControlExistContext(self, self._ctx, self.state)
self.enterRule(localctx, 236, self.RULE_controlExist)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1276
self.match(Fortran77Parser.EXIST)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ControlOpenedContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def OPENED(self):
return self.getToken(Fortran77Parser.OPENED, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_controlOpened
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterControlOpened" ):
listener.enterControlOpened(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitControlOpened" ):
listener.exitControlOpened(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitControlOpened" ):
return visitor.visitControlOpened(self)
else:
return visitor.visitChildren(self)
[docs]
def controlOpened(self):
localctx = Fortran77Parser.ControlOpenedContext(self, self._ctx, self.state)
self.enterRule(localctx, 238, self.RULE_controlOpened)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1278
self.match(Fortran77Parser.OPENED)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ControlNumberContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def NUMBER(self):
return self.getToken(Fortran77Parser.NUMBER, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_controlNumber
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterControlNumber" ):
listener.enterControlNumber(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitControlNumber" ):
listener.exitControlNumber(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitControlNumber" ):
return visitor.visitControlNumber(self)
else:
return visitor.visitChildren(self)
[docs]
def controlNumber(self):
localctx = Fortran77Parser.ControlNumberContext(self, self._ctx, self.state)
self.enterRule(localctx, 240, self.RULE_controlNumber)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1280
self.match(Fortran77Parser.NUMBER)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ControlNamedContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def NAMED(self):
return self.getToken(Fortran77Parser.NAMED, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_controlNamed
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterControlNamed" ):
listener.enterControlNamed(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitControlNamed" ):
listener.exitControlNamed(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitControlNamed" ):
return visitor.visitControlNamed(self)
else:
return visitor.visitChildren(self)
[docs]
def controlNamed(self):
localctx = Fortran77Parser.ControlNamedContext(self, self._ctx, self.state)
self.enterRule(localctx, 242, self.RULE_controlNamed)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1282
self.match(Fortran77Parser.NAMED)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ControlNameContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def NAME(self):
return self.getToken(Fortran77Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_controlName
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterControlName" ):
listener.enterControlName(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitControlName" ):
listener.exitControlName(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitControlName" ):
return visitor.visitControlName(self)
else:
return visitor.visitChildren(self)
[docs]
def controlName(self):
localctx = Fortran77Parser.ControlNameContext(self, self._ctx, self.state)
self.enterRule(localctx, 244, self.RULE_controlName)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1284
self.match(Fortran77Parser.NAME)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ControlSequentialContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def SEQUENTIAL(self):
return self.getToken(Fortran77Parser.SEQUENTIAL, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_controlSequential
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterControlSequential" ):
listener.enterControlSequential(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitControlSequential" ):
listener.exitControlSequential(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitControlSequential" ):
return visitor.visitControlSequential(self)
else:
return visitor.visitChildren(self)
[docs]
def controlSequential(self):
localctx = Fortran77Parser.ControlSequentialContext(self, self._ctx, self.state)
self.enterRule(localctx, 246, self.RULE_controlSequential)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1286
self.match(Fortran77Parser.SEQUENTIAL)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ControlDirectContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def NAME(self):
return self.getToken(Fortran77Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_controlDirect
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterControlDirect" ):
listener.enterControlDirect(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitControlDirect" ):
listener.exitControlDirect(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitControlDirect" ):
return visitor.visitControlDirect(self)
else:
return visitor.visitChildren(self)
[docs]
def controlDirect(self):
localctx = Fortran77Parser.ControlDirectContext(self, self._ctx, self.state)
self.enterRule(localctx, 248, self.RULE_controlDirect)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1288
self.match(Fortran77Parser.NAME)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ControlFormattedContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def FORMATTED(self):
return self.getToken(Fortran77Parser.FORMATTED, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_controlFormatted
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterControlFormatted" ):
listener.enterControlFormatted(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitControlFormatted" ):
listener.exitControlFormatted(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitControlFormatted" ):
return visitor.visitControlFormatted(self)
else:
return visitor.visitChildren(self)
[docs]
class ControlUnformattedContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def UNFORMATTED(self):
return self.getToken(Fortran77Parser.UNFORMATTED, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_controlUnformatted
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterControlUnformatted" ):
listener.enterControlUnformatted(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitControlUnformatted" ):
listener.exitControlUnformatted(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitControlUnformatted" ):
return visitor.visitControlUnformatted(self)
else:
return visitor.visitChildren(self)
[docs]
class ControlNextrecContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def NEXTREC(self):
return self.getToken(Fortran77Parser.NEXTREC, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_controlNextrec
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterControlNextrec" ):
listener.enterControlNextrec(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitControlNextrec" ):
listener.exitControlNextrec(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitControlNextrec" ):
return visitor.visitControlNextrec(self)
else:
return visitor.visitChildren(self)
[docs]
def controlNextrec(self):
localctx = Fortran77Parser.ControlNextrecContext(self, self._ctx, self.state)
self.enterRule(localctx, 254, self.RULE_controlNextrec)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1294
self.match(Fortran77Parser.NEXTREC)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class CloseStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def CLOSE(self):
return self.getToken(Fortran77Parser.CLOSE, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran77Parser.LPAREN, 0)
[docs]
def closeControl(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.CloseControlContext)
else:
return self.getTypedRuleContext(Fortran77Parser.CloseControlContext,i)
[docs]
def RPAREN(self):
return self.getToken(Fortran77Parser.RPAREN, 0)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.COMMA)
else:
return self.getToken(Fortran77Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_closeStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCloseStatement" ):
listener.enterCloseStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCloseStatement" ):
listener.exitCloseStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCloseStatement" ):
return visitor.visitCloseStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def closeStatement(self):
localctx = Fortran77Parser.CloseStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 256, self.RULE_closeStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1296
self.match(Fortran77Parser.CLOSE)
self.state = 1297
self.match(Fortran77Parser.LPAREN)
self.state = 1298
self.closeControl()
self.state = 1303
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.COMMA:
self.state = 1299
self.match(Fortran77Parser.COMMA)
self.state = 1300
self.closeControl()
self.state = 1305
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 1306
self.match(Fortran77Parser.RPAREN)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class CloseControlContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def unitIdentifier(self):
return self.getTypedRuleContext(Fortran77Parser.UnitIdentifierContext,0)
[docs]
def controlUnit(self):
return self.getTypedRuleContext(Fortran77Parser.ControlUnitContext,0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran77Parser.ASSIGN, 0)
[docs]
def controlErrSpec(self):
return self.getTypedRuleContext(Fortran77Parser.ControlErrSpecContext,0)
[docs]
def controlStatus(self):
return self.getTypedRuleContext(Fortran77Parser.ControlStatusContext,0)
[docs]
def characterExpression(self):
return self.getTypedRuleContext(Fortran77Parser.CharacterExpressionContext,0)
[docs]
def controlIostat(self):
return self.getTypedRuleContext(Fortran77Parser.ControlIostatContext,0)
[docs]
def varRef(self):
return self.getTypedRuleContext(Fortran77Parser.VarRefContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_closeControl
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCloseControl" ):
listener.enterCloseControl(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCloseControl" ):
listener.exitCloseControl(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCloseControl" ):
return visitor.visitCloseControl(self)
else:
return visitor.visitChildren(self)
[docs]
def closeControl(self):
localctx = Fortran77Parser.CloseControlContext(self, self._ctx, self.state)
self.enterRule(localctx, 258, self.RULE_closeControl)
try:
self.state = 1322
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran77Parser.LPAREN, Fortran77Parser.MINUS, Fortran77Parser.PLUS, Fortran77Parser.ICON, Fortran77Parser.NAME, Fortran77Parser.STAR]:
self.enterOuterAlt(localctx, 1)
self.state = 1308
self.unitIdentifier()
pass
elif token in [Fortran77Parser.UNIT]:
self.enterOuterAlt(localctx, 2)
self.state = 1309
self.controlUnit()
self.state = 1310
self.match(Fortran77Parser.ASSIGN)
self.state = 1311
self.unitIdentifier()
pass
elif token in [Fortran77Parser.ERR]:
self.enterOuterAlt(localctx, 3)
self.state = 1313
self.controlErrSpec()
pass
elif token in [Fortran77Parser.STATUS]:
self.enterOuterAlt(localctx, 4)
self.state = 1314
self.controlStatus()
self.state = 1315
self.match(Fortran77Parser.ASSIGN)
self.state = 1316
self.characterExpression()
pass
elif token in [Fortran77Parser.IOSTART]:
self.enterOuterAlt(localctx, 5)
self.state = 1318
self.controlIostat()
self.state = 1319
self.match(Fortran77Parser.ASSIGN)
self.state = 1320
self.varRef()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class InquireStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def INQUIRE(self):
return self.getToken(Fortran77Parser.INQUIRE, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran77Parser.LPAREN, 0)
[docs]
def inquireControl(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.InquireControlContext)
else:
return self.getTypedRuleContext(Fortran77Parser.InquireControlContext,i)
[docs]
def RPAREN(self):
return self.getToken(Fortran77Parser.RPAREN, 0)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.COMMA)
else:
return self.getToken(Fortran77Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_inquireStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterInquireStatement" ):
listener.enterInquireStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitInquireStatement" ):
listener.exitInquireStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitInquireStatement" ):
return visitor.visitInquireStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def inquireStatement(self):
localctx = Fortran77Parser.InquireStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 260, self.RULE_inquireStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1324
self.match(Fortran77Parser.INQUIRE)
self.state = 1325
self.match(Fortran77Parser.LPAREN)
self.state = 1326
self.inquireControl()
self.state = 1331
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.COMMA:
self.state = 1327
self.match(Fortran77Parser.COMMA)
self.state = 1328
self.inquireControl()
self.state = 1333
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 1334
self.match(Fortran77Parser.RPAREN)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class InquireControlContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def controlUnit(self):
return self.getTypedRuleContext(Fortran77Parser.ControlUnitContext,0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran77Parser.ASSIGN, 0)
[docs]
def unitIdentifier(self):
return self.getTypedRuleContext(Fortran77Parser.UnitIdentifierContext,0)
[docs]
def controlFile(self):
return self.getTypedRuleContext(Fortran77Parser.ControlFileContext,0)
[docs]
def characterExpression(self):
return self.getTypedRuleContext(Fortran77Parser.CharacterExpressionContext,0)
[docs]
def controlErrSpec(self):
return self.getTypedRuleContext(Fortran77Parser.ControlErrSpecContext,0)
[docs]
def varRef(self):
return self.getTypedRuleContext(Fortran77Parser.VarRefContext,0)
[docs]
def controlIostat(self):
return self.getTypedRuleContext(Fortran77Parser.ControlIostatContext,0)
[docs]
def controlExist(self):
return self.getTypedRuleContext(Fortran77Parser.ControlExistContext,0)
[docs]
def controlOpened(self):
return self.getTypedRuleContext(Fortran77Parser.ControlOpenedContext,0)
[docs]
def controlNumber(self):
return self.getTypedRuleContext(Fortran77Parser.ControlNumberContext,0)
[docs]
def controlNamed(self):
return self.getTypedRuleContext(Fortran77Parser.ControlNamedContext,0)
[docs]
def controlName(self):
return self.getTypedRuleContext(Fortran77Parser.ControlNameContext,0)
[docs]
def controlAccess(self):
return self.getTypedRuleContext(Fortran77Parser.ControlAccessContext,0)
[docs]
def controlSequential(self):
return self.getTypedRuleContext(Fortran77Parser.ControlSequentialContext,0)
[docs]
def controlDirect(self):
return self.getTypedRuleContext(Fortran77Parser.ControlDirectContext,0)
[docs]
def controlForm(self):
return self.getTypedRuleContext(Fortran77Parser.ControlFormContext,0)
[docs]
def controlFormatted(self):
return self.getTypedRuleContext(Fortran77Parser.ControlFormattedContext,0)
[docs]
def controlUnformatted(self):
return self.getTypedRuleContext(Fortran77Parser.ControlUnformattedContext,0)
[docs]
def controlRecl(self):
return self.getTypedRuleContext(Fortran77Parser.ControlReclContext,0)
[docs]
def controlNextrec(self):
return self.getTypedRuleContext(Fortran77Parser.ControlNextrecContext,0)
[docs]
def controlBlank(self):
return self.getTypedRuleContext(Fortran77Parser.ControlBlankContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_inquireControl
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterInquireControl" ):
listener.enterInquireControl(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitInquireControl" ):
listener.exitInquireControl(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitInquireControl" ):
return visitor.visitInquireControl(self)
else:
return visitor.visitChildren(self)
[docs]
def inquireControl(self):
localctx = Fortran77Parser.InquireControlContext(self, self._ctx, self.state)
self.enterRule(localctx, 262, self.RULE_inquireControl)
try:
self.state = 1366
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,116,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1336
self.controlUnit()
self.state = 1337
self.match(Fortran77Parser.ASSIGN)
self.state = 1338
self.unitIdentifier()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1340
self.controlFile()
self.state = 1341
self.match(Fortran77Parser.ASSIGN)
self.state = 1342
self.characterExpression()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 1344
self.controlErrSpec()
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 1360
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,115,self._ctx)
if la_ == 1:
self.state = 1345
self.controlIostat()
pass
elif la_ == 2:
self.state = 1346
self.controlExist()
pass
elif la_ == 3:
self.state = 1347
self.controlOpened()
pass
elif la_ == 4:
self.state = 1348
self.controlNumber()
pass
elif la_ == 5:
self.state = 1349
self.controlNamed()
pass
elif la_ == 6:
self.state = 1350
self.controlName()
pass
elif la_ == 7:
self.state = 1351
self.controlAccess()
pass
elif la_ == 8:
self.state = 1352
self.controlSequential()
pass
elif la_ == 9:
self.state = 1353
self.controlDirect()
pass
elif la_ == 10:
self.state = 1354
self.controlForm()
pass
elif la_ == 11:
self.state = 1355
self.controlFormatted()
pass
elif la_ == 12:
self.state = 1356
self.controlUnformatted()
pass
elif la_ == 13:
self.state = 1357
self.controlRecl()
pass
elif la_ == 14:
self.state = 1358
self.controlNextrec()
pass
elif la_ == 15:
self.state = 1359
self.controlBlank()
pass
self.state = 1362
self.match(Fortran77Parser.ASSIGN)
self.state = 1363
self.varRef()
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 1365
self.unitIdentifier()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class BackspaceStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def BACKSPACE(self):
return self.getToken(Fortran77Parser.BACKSPACE, 0)
[docs]
def berFinish(self):
return self.getTypedRuleContext(Fortran77Parser.BerFinishContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_backspaceStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterBackspaceStatement" ):
listener.enterBackspaceStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitBackspaceStatement" ):
listener.exitBackspaceStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitBackspaceStatement" ):
return visitor.visitBackspaceStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def backspaceStatement(self):
localctx = Fortran77Parser.BackspaceStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 264, self.RULE_backspaceStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1368
self.match(Fortran77Parser.BACKSPACE)
self.state = 1369
self.berFinish()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class EndfileStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ENDFILE(self):
return self.getToken(Fortran77Parser.ENDFILE, 0)
[docs]
def berFinish(self):
return self.getTypedRuleContext(Fortran77Parser.BerFinishContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_endfileStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEndfileStatement" ):
listener.enterEndfileStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEndfileStatement" ):
listener.exitEndfileStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEndfileStatement" ):
return visitor.visitEndfileStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def endfileStatement(self):
localctx = Fortran77Parser.EndfileStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 266, self.RULE_endfileStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1371
self.match(Fortran77Parser.ENDFILE)
self.state = 1372
self.berFinish()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class RewindStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def REWIND(self):
return self.getToken(Fortran77Parser.REWIND, 0)
[docs]
def berFinish(self):
return self.getTypedRuleContext(Fortran77Parser.BerFinishContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_rewindStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterRewindStatement" ):
listener.enterRewindStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitRewindStatement" ):
listener.exitRewindStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitRewindStatement" ):
return visitor.visitRewindStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def rewindStatement(self):
localctx = Fortran77Parser.RewindStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 268, self.RULE_rewindStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1374
self.match(Fortran77Parser.REWIND)
self.state = 1375
self.berFinish()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class BerFinishContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def unitIdentifier(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.UnitIdentifierContext)
else:
return self.getTypedRuleContext(Fortran77Parser.UnitIdentifierContext,i)
[docs]
def LPAREN(self):
return self.getToken(Fortran77Parser.LPAREN, 0)
[docs]
def berFinishItem(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.BerFinishItemContext)
else:
return self.getTypedRuleContext(Fortran77Parser.BerFinishItemContext,i)
[docs]
def RPAREN(self):
return self.getToken(Fortran77Parser.RPAREN, 0)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.COMMA)
else:
return self.getToken(Fortran77Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_berFinish
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterBerFinish" ):
listener.enterBerFinish(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitBerFinish" ):
listener.exitBerFinish(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitBerFinish" ):
return visitor.visitBerFinish(self)
else:
return visitor.visitChildren(self)
[docs]
def berFinish(self):
localctx = Fortran77Parser.BerFinishContext(self, self._ctx, self.state)
self.enterRule(localctx, 270, self.RULE_berFinish)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1391
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,118,self._ctx)
if la_ == 1:
self.state = 1377
self.unitIdentifier()
self.state = 1378
self.unitIdentifier()
pass
elif la_ == 2:
self.state = 1380
self.match(Fortran77Parser.LPAREN)
self.state = 1381
self.berFinishItem()
self.state = 1386
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.COMMA:
self.state = 1382
self.match(Fortran77Parser.COMMA)
self.state = 1383
self.berFinishItem()
self.state = 1388
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 1389
self.match(Fortran77Parser.RPAREN)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class BerFinishItemContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def unitIdentifier(self):
return self.getTypedRuleContext(Fortran77Parser.UnitIdentifierContext,0)
[docs]
def controlUnit(self):
return self.getTypedRuleContext(Fortran77Parser.ControlUnitContext,0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran77Parser.ASSIGN, 0)
[docs]
def controlErrSpec(self):
return self.getTypedRuleContext(Fortran77Parser.ControlErrSpecContext,0)
[docs]
def controlIostat(self):
return self.getTypedRuleContext(Fortran77Parser.ControlIostatContext,0)
[docs]
def varRef(self):
return self.getTypedRuleContext(Fortran77Parser.VarRefContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_berFinishItem
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterBerFinishItem" ):
listener.enterBerFinishItem(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitBerFinishItem" ):
listener.exitBerFinishItem(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitBerFinishItem" ):
return visitor.visitBerFinishItem(self)
else:
return visitor.visitChildren(self)
[docs]
def berFinishItem(self):
localctx = Fortran77Parser.BerFinishItemContext(self, self._ctx, self.state)
self.enterRule(localctx, 272, self.RULE_berFinishItem)
try:
self.state = 1403
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran77Parser.LPAREN, Fortran77Parser.MINUS, Fortran77Parser.PLUS, Fortran77Parser.ICON, Fortran77Parser.NAME, Fortran77Parser.STAR]:
self.enterOuterAlt(localctx, 1)
self.state = 1393
self.unitIdentifier()
pass
elif token in [Fortran77Parser.UNIT]:
self.enterOuterAlt(localctx, 2)
self.state = 1394
self.controlUnit()
self.state = 1395
self.match(Fortran77Parser.ASSIGN)
self.state = 1396
self.unitIdentifier()
pass
elif token in [Fortran77Parser.ERR]:
self.enterOuterAlt(localctx, 3)
self.state = 1398
self.controlErrSpec()
pass
elif token in [Fortran77Parser.IOSTART]:
self.enterOuterAlt(localctx, 4)
self.state = 1399
self.controlIostat()
self.state = 1400
self.match(Fortran77Parser.ASSIGN)
self.state = 1401
self.varRef()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class UnitIdentifierContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def iexpr(self):
return self.getTypedRuleContext(Fortran77Parser.IexprContext,0)
[docs]
def STAR(self):
return self.getToken(Fortran77Parser.STAR, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_unitIdentifier
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterUnitIdentifier" ):
listener.enterUnitIdentifier(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitUnitIdentifier" ):
listener.exitUnitIdentifier(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitUnitIdentifier" ):
return visitor.visitUnitIdentifier(self)
else:
return visitor.visitChildren(self)
[docs]
def unitIdentifier(self):
localctx = Fortran77Parser.UnitIdentifierContext(self, self._ctx, self.state)
self.enterRule(localctx, 274, self.RULE_unitIdentifier)
try:
self.state = 1407
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran77Parser.LPAREN, Fortran77Parser.MINUS, Fortran77Parser.PLUS, Fortran77Parser.ICON, Fortran77Parser.NAME]:
self.enterOuterAlt(localctx, 1)
self.state = 1405
self.iexpr()
pass
elif token in [Fortran77Parser.STAR]:
self.enterOuterAlt(localctx, 2)
self.state = 1406
self.match(Fortran77Parser.STAR)
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class FormatIdentifierContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def SCON(self):
return self.getToken(Fortran77Parser.SCON, 0)
[docs]
def HOLLERITH(self):
return self.getToken(Fortran77Parser.HOLLERITH, 0)
[docs]
def iexpr(self):
return self.getTypedRuleContext(Fortran77Parser.IexprContext,0)
[docs]
def STAR(self):
return self.getToken(Fortran77Parser.STAR, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_formatIdentifier
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterFormatIdentifier" ):
listener.enterFormatIdentifier(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitFormatIdentifier" ):
listener.exitFormatIdentifier(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFormatIdentifier" ):
return visitor.visitFormatIdentifier(self)
else:
return visitor.visitChildren(self)
[docs]
class FormatStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def FORMAT(self):
return self.getToken(Fortran77Parser.FORMAT, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran77Parser.LPAREN, 0)
[docs]
def fmtSpec(self):
return self.getTypedRuleContext(Fortran77Parser.FmtSpecContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran77Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_formatStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterFormatStatement" ):
listener.enterFormatStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitFormatStatement" ):
listener.exitFormatStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFormatStatement" ):
return visitor.visitFormatStatement(self)
else:
return visitor.visitChildren(self)
[docs]
class FmtSpecContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def formatedit(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.FormateditContext)
else:
return self.getTypedRuleContext(Fortran77Parser.FormateditContext,i)
[docs]
def formatsep(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.FormatsepContext)
else:
return self.getTypedRuleContext(Fortran77Parser.FormatsepContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.COMMA)
else:
return self.getToken(Fortran77Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_fmtSpec
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterFmtSpec" ):
listener.enterFmtSpec(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitFmtSpec" ):
listener.exitFmtSpec(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFmtSpec" ):
return visitor.visitFmtSpec(self)
else:
return visitor.visitChildren(self)
[docs]
def fmtSpec(self):
localctx = Fortran77Parser.FmtSpecContext(self, self._ctx, self.state)
self.enterRule(localctx, 280, self.RULE_fmtSpec)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1424
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran77Parser.LPAREN, Fortran77Parser.MINUS, Fortran77Parser.PLUS, Fortran77Parser.XCON, Fortran77Parser.PCON, Fortran77Parser.FCON, Fortran77Parser.HOLLERITH, Fortran77Parser.SCON, Fortran77Parser.ICON, Fortran77Parser.NAME]:
self.state = 1419
self.formatedit()
pass
elif token in [Fortran77Parser.DOLLAR, Fortran77Parser.COLON, Fortran77Parser.DIV]:
self.state = 1420
self.formatsep()
self.state = 1422
self._errHandler.sync(self)
_la = self._input.LA(1)
if ((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & ((1 << (Fortran77Parser.LPAREN - 70)) | (1 << (Fortran77Parser.MINUS - 70)) | (1 << (Fortran77Parser.PLUS - 70)) | (1 << (Fortran77Parser.XCON - 70)) | (1 << (Fortran77Parser.PCON - 70)) | (1 << (Fortran77Parser.FCON - 70)) | (1 << (Fortran77Parser.HOLLERITH - 70)) | (1 << (Fortran77Parser.SCON - 70)) | (1 << (Fortran77Parser.ICON - 70)) | (1 << (Fortran77Parser.NAME - 70)))) != 0):
self.state = 1421
self.formatedit()
pass
else:
raise NoViableAltException(self)
self.state = 1440
self._errHandler.sync(self)
_la = self._input.LA(1)
while ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (Fortran77Parser.DOLLAR - 68)) | (1 << (Fortran77Parser.COMMA - 68)) | (1 << (Fortran77Parser.COLON - 68)) | (1 << (Fortran77Parser.DIV - 68)))) != 0):
self.state = 1438
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran77Parser.DOLLAR, Fortran77Parser.COLON, Fortran77Parser.DIV]:
self.state = 1426
self.formatsep()
self.state = 1428
self._errHandler.sync(self)
_la = self._input.LA(1)
if ((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & ((1 << (Fortran77Parser.LPAREN - 70)) | (1 << (Fortran77Parser.MINUS - 70)) | (1 << (Fortran77Parser.PLUS - 70)) | (1 << (Fortran77Parser.XCON - 70)) | (1 << (Fortran77Parser.PCON - 70)) | (1 << (Fortran77Parser.FCON - 70)) | (1 << (Fortran77Parser.HOLLERITH - 70)) | (1 << (Fortran77Parser.SCON - 70)) | (1 << (Fortran77Parser.ICON - 70)) | (1 << (Fortran77Parser.NAME - 70)))) != 0):
self.state = 1427
self.formatedit()
pass
elif token in [Fortran77Parser.COMMA]:
self.state = 1430
self.match(Fortran77Parser.COMMA)
self.state = 1436
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran77Parser.LPAREN, Fortran77Parser.MINUS, Fortran77Parser.PLUS, Fortran77Parser.XCON, Fortran77Parser.PCON, Fortran77Parser.FCON, Fortran77Parser.HOLLERITH, Fortran77Parser.SCON, Fortran77Parser.ICON, Fortran77Parser.NAME]:
self.state = 1431
self.formatedit()
pass
elif token in [Fortran77Parser.DOLLAR, Fortran77Parser.COLON, Fortran77Parser.DIV]:
self.state = 1432
self.formatsep()
self.state = 1434
self._errHandler.sync(self)
_la = self._input.LA(1)
if ((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & ((1 << (Fortran77Parser.LPAREN - 70)) | (1 << (Fortran77Parser.MINUS - 70)) | (1 << (Fortran77Parser.PLUS - 70)) | (1 << (Fortran77Parser.XCON - 70)) | (1 << (Fortran77Parser.PCON - 70)) | (1 << (Fortran77Parser.FCON - 70)) | (1 << (Fortran77Parser.HOLLERITH - 70)) | (1 << (Fortran77Parser.SCON - 70)) | (1 << (Fortran77Parser.ICON - 70)) | (1 << (Fortran77Parser.NAME - 70)))) != 0):
self.state = 1433
self.formatedit()
pass
else:
raise NoViableAltException(self)
pass
else:
raise NoViableAltException(self)
self.state = 1442
self._errHandler.sync(self)
_la = self._input.LA(1)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class FormatsepContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def DIV(self):
return self.getToken(Fortran77Parser.DIV, 0)
[docs]
def COLON(self):
return self.getToken(Fortran77Parser.COLON, 0)
[docs]
def DOLLAR(self):
return self.getToken(Fortran77Parser.DOLLAR, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_formatsep
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterFormatsep" ):
listener.enterFormatsep(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitFormatsep" ):
listener.exitFormatsep(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFormatsep" ):
return visitor.visitFormatsep(self)
else:
return visitor.visitChildren(self)
[docs]
class FormateditContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def XCON(self):
return self.getToken(Fortran77Parser.XCON, 0)
[docs]
def editElement(self):
return self.getTypedRuleContext(Fortran77Parser.EditElementContext,0)
[docs]
def ICON(self):
return self.getToken(Fortran77Parser.ICON, 0)
[docs]
def PCON(self):
return self.getToken(Fortran77Parser.PCON, 0)
[docs]
def PLUS(self):
return self.getToken(Fortran77Parser.PLUS, 0)
[docs]
def MINUS(self):
return self.getToken(Fortran77Parser.MINUS, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_formatedit
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterFormatedit" ):
listener.enterFormatedit(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitFormatedit" ):
listener.exitFormatedit(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFormatedit" ):
return visitor.visitFormatedit(self)
else:
return visitor.visitChildren(self)
[docs]
class EditElementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def FCON(self):
return self.getToken(Fortran77Parser.FCON, 0)
[docs]
def SCON(self):
return self.getToken(Fortran77Parser.SCON, 0)
[docs]
def HOLLERITH(self):
return self.getToken(Fortran77Parser.HOLLERITH, 0)
[docs]
def NAME(self):
return self.getToken(Fortran77Parser.NAME, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran77Parser.LPAREN, 0)
[docs]
def fmtSpec(self):
return self.getTypedRuleContext(Fortran77Parser.FmtSpecContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran77Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_editElement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEditElement" ):
listener.enterEditElement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEditElement" ):
listener.exitEditElement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEditElement" ):
return visitor.visitEditElement(self)
else:
return visitor.visitChildren(self)
[docs]
def editElement(self):
localctx = Fortran77Parser.EditElementContext(self, self._ctx, self.state)
self.enterRule(localctx, 286, self.RULE_editElement)
self._la = 0 # Token type
try:
self.state = 1466
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran77Parser.FCON, Fortran77Parser.HOLLERITH, Fortran77Parser.SCON, Fortran77Parser.NAME]:
self.enterOuterAlt(localctx, 1)
self.state = 1461
_la = self._input.LA(1)
if not(((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & ((1 << (Fortran77Parser.FCON - 95)) | (1 << (Fortran77Parser.HOLLERITH - 95)) | (1 << (Fortran77Parser.SCON - 95)) | (1 << (Fortran77Parser.NAME - 95)))) != 0)):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
pass
elif token in [Fortran77Parser.LPAREN]:
self.enterOuterAlt(localctx, 2)
self.state = 1462
self.match(Fortran77Parser.LPAREN)
self.state = 1463
self.fmtSpec()
self.state = 1464
self.match(Fortran77Parser.RPAREN)
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class StatementFunctionStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def LET(self):
return self.getToken(Fortran77Parser.LET, 0)
[docs]
def sfArgs(self):
return self.getTypedRuleContext(Fortran77Parser.SfArgsContext,0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran77Parser.ASSIGN, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran77Parser.ExpressionContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_statementFunctionStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterStatementFunctionStatement" ):
listener.enterStatementFunctionStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitStatementFunctionStatement" ):
listener.exitStatementFunctionStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitStatementFunctionStatement" ):
return visitor.visitStatementFunctionStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def statementFunctionStatement(self):
localctx = Fortran77Parser.StatementFunctionStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 288, self.RULE_statementFunctionStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1468
self.match(Fortran77Parser.LET)
self.state = 1469
self.sfArgs()
self.state = 1470
self.match(Fortran77Parser.ASSIGN)
self.state = 1471
self.expression()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class SfArgsContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def NAME(self):
return self.getToken(Fortran77Parser.NAME, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran77Parser.LPAREN, 0)
[docs]
def namelist(self):
return self.getTypedRuleContext(Fortran77Parser.NamelistContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran77Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_sfArgs
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSfArgs" ):
listener.enterSfArgs(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSfArgs" ):
listener.exitSfArgs(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSfArgs" ):
return visitor.visitSfArgs(self)
else:
return visitor.visitChildren(self)
[docs]
def sfArgs(self):
localctx = Fortran77Parser.SfArgsContext(self, self._ctx, self.state)
self.enterRule(localctx, 290, self.RULE_sfArgs)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1473
self.match(Fortran77Parser.NAME)
self.state = 1474
self.match(Fortran77Parser.LPAREN)
self.state = 1475
self.namelist()
self.state = 1476
self.match(Fortran77Parser.RPAREN)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class CallStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def CALL(self):
return self.getToken(Fortran77Parser.CALL, 0)
[docs]
def subroutineCall(self):
return self.getTypedRuleContext(Fortran77Parser.SubroutineCallContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_callStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCallStatement" ):
listener.enterCallStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCallStatement" ):
listener.exitCallStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCallStatement" ):
return visitor.visitCallStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def callStatement(self):
localctx = Fortran77Parser.CallStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 292, self.RULE_callStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1478
self.match(Fortran77Parser.CALL)
self.state = 1479
self.subroutineCall()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class SubroutineCallContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def NAME(self):
return self.getToken(Fortran77Parser.NAME, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran77Parser.LPAREN, 0)
[docs]
def RPAREN(self):
return self.getToken(Fortran77Parser.RPAREN, 0)
[docs]
def callArgumentList(self):
return self.getTypedRuleContext(Fortran77Parser.CallArgumentListContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_subroutineCall
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSubroutineCall" ):
listener.enterSubroutineCall(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSubroutineCall" ):
listener.exitSubroutineCall(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSubroutineCall" ):
return visitor.visitSubroutineCall(self)
else:
return visitor.visitChildren(self)
[docs]
def subroutineCall(self):
localctx = Fortran77Parser.SubroutineCallContext(self, self._ctx, self.state)
self.enterRule(localctx, 294, self.RULE_subroutineCall)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1481
self.match(Fortran77Parser.NAME)
self.state = 1487
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.LPAREN:
self.state = 1482
self.match(Fortran77Parser.LPAREN)
self.state = 1484
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.REAL or ((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & ((1 << (Fortran77Parser.LPAREN - 70)) | (1 << (Fortran77Parser.MINUS - 70)) | (1 << (Fortran77Parser.PLUS - 70)) | (1 << (Fortran77Parser.LNOT - 70)) | (1 << (Fortran77Parser.TRUE - 70)) | (1 << (Fortran77Parser.FALSE - 70)) | (1 << (Fortran77Parser.HOLLERITH - 70)) | (1 << (Fortran77Parser.SCON - 70)) | (1 << (Fortran77Parser.RCON - 70)) | (1 << (Fortran77Parser.ICON - 70)) | (1 << (Fortran77Parser.NAME - 70)) | (1 << (Fortran77Parser.STAR - 70)))) != 0):
self.state = 1483
self.callArgumentList()
self.state = 1486
self.match(Fortran77Parser.RPAREN)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class CallArgumentListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def callArgument(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.CallArgumentContext)
else:
return self.getTypedRuleContext(Fortran77Parser.CallArgumentContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.COMMA)
else:
return self.getToken(Fortran77Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_callArgumentList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCallArgumentList" ):
listener.enterCallArgumentList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCallArgumentList" ):
listener.exitCallArgumentList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCallArgumentList" ):
return visitor.visitCallArgumentList(self)
else:
return visitor.visitChildren(self)
[docs]
def callArgumentList(self):
localctx = Fortran77Parser.CallArgumentListContext(self, self._ctx, self.state)
self.enterRule(localctx, 296, self.RULE_callArgumentList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1489
self.callArgument()
self.state = 1494
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.COMMA:
self.state = 1490
self.match(Fortran77Parser.COMMA)
self.state = 1491
self.callArgument()
self.state = 1496
self._errHandler.sync(self)
_la = self._input.LA(1)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class CallArgumentContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran77Parser.ExpressionContext,0)
[docs]
def STAR(self):
return self.getToken(Fortran77Parser.STAR, 0)
[docs]
def lblRef(self):
return self.getTypedRuleContext(Fortran77Parser.LblRefContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_callArgument
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCallArgument" ):
listener.enterCallArgument(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCallArgument" ):
listener.exitCallArgument(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCallArgument" ):
return visitor.visitCallArgument(self)
else:
return visitor.visitChildren(self)
[docs]
def callArgument(self):
localctx = Fortran77Parser.CallArgumentContext(self, self._ctx, self.state)
self.enterRule(localctx, 298, self.RULE_callArgument)
try:
self.state = 1500
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran77Parser.REAL, Fortran77Parser.LPAREN, Fortran77Parser.MINUS, Fortran77Parser.PLUS, Fortran77Parser.LNOT, Fortran77Parser.TRUE, Fortran77Parser.FALSE, Fortran77Parser.HOLLERITH, Fortran77Parser.SCON, Fortran77Parser.RCON, Fortran77Parser.ICON, Fortran77Parser.NAME]:
self.enterOuterAlt(localctx, 1)
self.state = 1497
self.expression()
pass
elif token in [Fortran77Parser.STAR]:
self.enterOuterAlt(localctx, 2)
self.state = 1498
self.match(Fortran77Parser.STAR)
self.state = 1499
self.lblRef()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ReturnStatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def RETURN(self):
return self.getToken(Fortran77Parser.RETURN, 0)
[docs]
def integerExpr(self):
return self.getTypedRuleContext(Fortran77Parser.IntegerExprContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_returnStatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterReturnStatement" ):
listener.enterReturnStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitReturnStatement" ):
listener.exitReturnStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitReturnStatement" ):
return visitor.visitReturnStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def returnStatement(self):
localctx = Fortran77Parser.ReturnStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 300, self.RULE_returnStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1502
self.match(Fortran77Parser.RETURN)
self.state = 1504
self._errHandler.sync(self)
_la = self._input.LA(1)
if ((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & ((1 << (Fortran77Parser.LPAREN - 70)) | (1 << (Fortran77Parser.MINUS - 70)) | (1 << (Fortran77Parser.PLUS - 70)) | (1 << (Fortran77Parser.ICON - 70)) | (1 << (Fortran77Parser.NAME - 70)))) != 0):
self.state = 1503
self.integerExpr()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ExpressionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ncExpr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.NcExprContext)
else:
return self.getTypedRuleContext(Fortran77Parser.NcExprContext,i)
[docs]
def COLON(self):
return self.getToken(Fortran77Parser.COLON, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_expression
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterExpression" ):
listener.enterExpression(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitExpression" ):
listener.exitExpression(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitExpression" ):
return visitor.visitExpression(self)
else:
return visitor.visitChildren(self)
[docs]
def expression(self):
localctx = Fortran77Parser.ExpressionContext(self, self._ctx, self.state)
self.enterRule(localctx, 302, self.RULE_expression)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1506
self.ncExpr()
self.state = 1509
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.COLON:
self.state = 1507
self.match(Fortran77Parser.COLON)
self.state = 1508
self.ncExpr()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class NcExprContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def lexpr0(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.Lexpr0Context)
else:
return self.getTypedRuleContext(Fortran77Parser.Lexpr0Context,i)
[docs]
def concatOp(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.ConcatOpContext)
else:
return self.getTypedRuleContext(Fortran77Parser.ConcatOpContext,i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_ncExpr
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterNcExpr" ):
listener.enterNcExpr(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitNcExpr" ):
listener.exitNcExpr(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNcExpr" ):
return visitor.visitNcExpr(self)
else:
return visitor.visitChildren(self)
[docs]
def ncExpr(self):
localctx = Fortran77Parser.NcExprContext(self, self._ctx, self.state)
self.enterRule(localctx, 304, self.RULE_ncExpr)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1511
self.lexpr0()
self.state = 1517
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.DIV:
self.state = 1512
self.concatOp()
self.state = 1513
self.lexpr0()
self.state = 1519
self._errHandler.sync(self)
_la = self._input.LA(1)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Lexpr0Context(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def lexpr1(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.Lexpr1Context)
else:
return self.getTypedRuleContext(Fortran77Parser.Lexpr1Context,i)
[docs]
def NEQV(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.NEQV)
else:
return self.getToken(Fortran77Parser.NEQV, i)
[docs]
def EQV(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.EQV)
else:
return self.getToken(Fortran77Parser.EQV, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_lexpr0
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLexpr0" ):
listener.enterLexpr0(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLexpr0" ):
listener.exitLexpr0(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLexpr0" ):
return visitor.visitLexpr0(self)
else:
return visitor.visitChildren(self)
[docs]
def lexpr0(self):
localctx = Fortran77Parser.Lexpr0Context(self, self._ctx, self.state)
self.enterRule(localctx, 306, self.RULE_lexpr0)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1520
self.lexpr1()
self.state = 1525
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.EQV or _la==Fortran77Parser.NEQV:
self.state = 1521
_la = self._input.LA(1)
if not(_la==Fortran77Parser.EQV or _la==Fortran77Parser.NEQV):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 1522
self.lexpr1()
self.state = 1527
self._errHandler.sync(self)
_la = self._input.LA(1)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Lexpr1Context(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def lexpr2(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.Lexpr2Context)
else:
return self.getTypedRuleContext(Fortran77Parser.Lexpr2Context,i)
[docs]
def LOR(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.LOR)
else:
return self.getToken(Fortran77Parser.LOR, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_lexpr1
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLexpr1" ):
listener.enterLexpr1(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLexpr1" ):
listener.exitLexpr1(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLexpr1" ):
return visitor.visitLexpr1(self)
else:
return visitor.visitChildren(self)
[docs]
def lexpr1(self):
localctx = Fortran77Parser.Lexpr1Context(self, self._ctx, self.state)
self.enterRule(localctx, 308, self.RULE_lexpr1)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1528
self.lexpr2()
self.state = 1533
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.LOR:
self.state = 1529
self.match(Fortran77Parser.LOR)
self.state = 1530
self.lexpr2()
self.state = 1535
self._errHandler.sync(self)
_la = self._input.LA(1)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Lexpr2Context(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def lexpr3(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.Lexpr3Context)
else:
return self.getTypedRuleContext(Fortran77Parser.Lexpr3Context,i)
[docs]
def LAND(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.LAND)
else:
return self.getToken(Fortran77Parser.LAND, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_lexpr2
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLexpr2" ):
listener.enterLexpr2(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLexpr2" ):
listener.exitLexpr2(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLexpr2" ):
return visitor.visitLexpr2(self)
else:
return visitor.visitChildren(self)
[docs]
def lexpr2(self):
localctx = Fortran77Parser.Lexpr2Context(self, self._ctx, self.state)
self.enterRule(localctx, 310, self.RULE_lexpr2)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1536
self.lexpr3()
self.state = 1541
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.LAND:
self.state = 1537
self.match(Fortran77Parser.LAND)
self.state = 1538
self.lexpr3()
self.state = 1543
self._errHandler.sync(self)
_la = self._input.LA(1)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Lexpr3Context(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def LNOT(self):
return self.getToken(Fortran77Parser.LNOT, 0)
[docs]
def lexpr3(self):
return self.getTypedRuleContext(Fortran77Parser.Lexpr3Context,0)
[docs]
def lexpr4(self):
return self.getTypedRuleContext(Fortran77Parser.Lexpr4Context,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_lexpr3
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLexpr3" ):
listener.enterLexpr3(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLexpr3" ):
listener.exitLexpr3(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLexpr3" ):
return visitor.visitLexpr3(self)
else:
return visitor.visitChildren(self)
[docs]
def lexpr3(self):
localctx = Fortran77Parser.Lexpr3Context(self, self._ctx, self.state)
self.enterRule(localctx, 312, self.RULE_lexpr3)
try:
self.state = 1547
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran77Parser.LNOT]:
self.enterOuterAlt(localctx, 1)
self.state = 1544
self.match(Fortran77Parser.LNOT)
self.state = 1545
self.lexpr3()
pass
elif token in [Fortran77Parser.REAL, Fortran77Parser.LPAREN, Fortran77Parser.MINUS, Fortran77Parser.PLUS, Fortran77Parser.TRUE, Fortran77Parser.FALSE, Fortran77Parser.HOLLERITH, Fortran77Parser.SCON, Fortran77Parser.RCON, Fortran77Parser.ICON, Fortran77Parser.NAME]:
self.enterOuterAlt(localctx, 2)
self.state = 1546
self.lexpr4()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Lexpr4Context(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def aexpr0(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.Aexpr0Context)
else:
return self.getTypedRuleContext(Fortran77Parser.Aexpr0Context,i)
[docs]
def LT(self):
return self.getToken(Fortran77Parser.LT, 0)
[docs]
def LE(self):
return self.getToken(Fortran77Parser.LE, 0)
[docs]
def EQ(self):
return self.getToken(Fortran77Parser.EQ, 0)
[docs]
def NE(self):
return self.getToken(Fortran77Parser.NE, 0)
[docs]
def GT(self):
return self.getToken(Fortran77Parser.GT, 0)
[docs]
def GE(self):
return self.getToken(Fortran77Parser.GE, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_lexpr4
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLexpr4" ):
listener.enterLexpr4(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLexpr4" ):
listener.exitLexpr4(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLexpr4" ):
return visitor.visitLexpr4(self)
else:
return visitor.visitChildren(self)
[docs]
def lexpr4(self):
localctx = Fortran77Parser.Lexpr4Context(self, self._ctx, self.state)
self.enterRule(localctx, 314, self.RULE_lexpr4)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1549
self.aexpr0()
self.state = 1552
self._errHandler.sync(self)
_la = self._input.LA(1)
if ((((_la - 85)) & ~0x3f) == 0 and ((1 << (_la - 85)) & ((1 << (Fortran77Parser.LT - 85)) | (1 << (Fortran77Parser.LE - 85)) | (1 << (Fortran77Parser.GT - 85)) | (1 << (Fortran77Parser.GE - 85)) | (1 << (Fortran77Parser.NE - 85)) | (1 << (Fortran77Parser.EQ - 85)))) != 0):
self.state = 1550
_la = self._input.LA(1)
if not(((((_la - 85)) & ~0x3f) == 0 and ((1 << (_la - 85)) & ((1 << (Fortran77Parser.LT - 85)) | (1 << (Fortran77Parser.LE - 85)) | (1 << (Fortran77Parser.GT - 85)) | (1 << (Fortran77Parser.GE - 85)) | (1 << (Fortran77Parser.NE - 85)) | (1 << (Fortran77Parser.EQ - 85)))) != 0)):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 1551
self.aexpr0()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Aexpr0Context(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def aexpr1(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.Aexpr1Context)
else:
return self.getTypedRuleContext(Fortran77Parser.Aexpr1Context,i)
[docs]
def PLUS(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.PLUS)
else:
return self.getToken(Fortran77Parser.PLUS, i)
[docs]
def MINUS(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.MINUS)
else:
return self.getToken(Fortran77Parser.MINUS, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_aexpr0
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAexpr0" ):
listener.enterAexpr0(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAexpr0" ):
listener.exitAexpr0(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAexpr0" ):
return visitor.visitAexpr0(self)
else:
return visitor.visitChildren(self)
[docs]
def aexpr0(self):
localctx = Fortran77Parser.Aexpr0Context(self, self._ctx, self.state)
self.enterRule(localctx, 316, self.RULE_aexpr0)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1554
self.aexpr1()
self.state = 1559
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,146,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 1555
_la = self._input.LA(1)
if not(_la==Fortran77Parser.MINUS or _la==Fortran77Parser.PLUS):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 1556
self.aexpr1()
self.state = 1561
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,146,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Aexpr1Context(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def aexpr2(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.Aexpr2Context)
else:
return self.getTypedRuleContext(Fortran77Parser.Aexpr2Context,i)
[docs]
def STAR(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.STAR)
else:
return self.getToken(Fortran77Parser.STAR, i)
[docs]
def DIV(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.DIV)
else:
return self.getToken(Fortran77Parser.DIV, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_aexpr1
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAexpr1" ):
listener.enterAexpr1(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAexpr1" ):
listener.exitAexpr1(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAexpr1" ):
return visitor.visitAexpr1(self)
else:
return visitor.visitChildren(self)
[docs]
def aexpr1(self):
localctx = Fortran77Parser.Aexpr1Context(self, self._ctx, self.state)
self.enterRule(localctx, 318, self.RULE_aexpr1)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1562
self.aexpr2()
self.state = 1567
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,147,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 1563
_la = self._input.LA(1)
if not(_la==Fortran77Parser.DIV or _la==Fortran77Parser.STAR):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 1564
self.aexpr2()
self.state = 1569
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,147,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Aexpr2Context(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def aexpr3(self):
return self.getTypedRuleContext(Fortran77Parser.Aexpr3Context,0)
[docs]
def PLUS(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.PLUS)
else:
return self.getToken(Fortran77Parser.PLUS, i)
[docs]
def MINUS(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.MINUS)
else:
return self.getToken(Fortran77Parser.MINUS, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_aexpr2
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAexpr2" ):
listener.enterAexpr2(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAexpr2" ):
listener.exitAexpr2(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAexpr2" ):
return visitor.visitAexpr2(self)
else:
return visitor.visitChildren(self)
[docs]
def aexpr2(self):
localctx = Fortran77Parser.Aexpr2Context(self, self._ctx, self.state)
self.enterRule(localctx, 320, self.RULE_aexpr2)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1573
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.MINUS or _la==Fortran77Parser.PLUS:
self.state = 1570
_la = self._input.LA(1)
if not(_la==Fortran77Parser.MINUS or _la==Fortran77Parser.PLUS):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 1575
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 1576
self.aexpr3()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Aexpr3Context(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def aexpr4(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.Aexpr4Context)
else:
return self.getTypedRuleContext(Fortran77Parser.Aexpr4Context,i)
[docs]
def POWER(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.POWER)
else:
return self.getToken(Fortran77Parser.POWER, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_aexpr3
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAexpr3" ):
listener.enterAexpr3(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAexpr3" ):
listener.exitAexpr3(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAexpr3" ):
return visitor.visitAexpr3(self)
else:
return visitor.visitChildren(self)
[docs]
def aexpr3(self):
localctx = Fortran77Parser.Aexpr3Context(self, self._ctx, self.state)
self.enterRule(localctx, 322, self.RULE_aexpr3)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1578
self.aexpr4()
self.state = 1583
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.POWER:
self.state = 1579
self.match(Fortran77Parser.POWER)
self.state = 1580
self.aexpr4()
self.state = 1585
self._errHandler.sync(self)
_la = self._input.LA(1)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Aexpr4Context(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def unsignedArithmeticConstant(self):
return self.getTypedRuleContext(Fortran77Parser.UnsignedArithmeticConstantContext,0)
[docs]
def HOLLERITH(self):
return self.getToken(Fortran77Parser.HOLLERITH, 0)
[docs]
def SCON(self):
return self.getToken(Fortran77Parser.SCON, 0)
[docs]
def logicalConstant(self):
return self.getTypedRuleContext(Fortran77Parser.LogicalConstantContext,0)
[docs]
def varRef(self):
return self.getTypedRuleContext(Fortran77Parser.VarRefContext,0)
[docs]
def LPAREN(self):
return self.getToken(Fortran77Parser.LPAREN, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran77Parser.ExpressionContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran77Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_aexpr4
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAexpr4" ):
listener.enterAexpr4(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAexpr4" ):
listener.exitAexpr4(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAexpr4" ):
return visitor.visitAexpr4(self)
else:
return visitor.visitChildren(self)
[docs]
def aexpr4(self):
localctx = Fortran77Parser.Aexpr4Context(self, self._ctx, self.state)
self.enterRule(localctx, 324, self.RULE_aexpr4)
self._la = 0 # Token type
try:
self.state = 1594
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,150,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1586
self.unsignedArithmeticConstant()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1587
_la = self._input.LA(1)
if not(_la==Fortran77Parser.HOLLERITH or _la==Fortran77Parser.SCON):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 1588
self.logicalConstant()
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 1589
self.varRef()
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 1590
self.match(Fortran77Parser.LPAREN)
self.state = 1591
self.expression()
self.state = 1592
self.match(Fortran77Parser.RPAREN)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class IexprContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def iexpr1(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.Iexpr1Context)
else:
return self.getTypedRuleContext(Fortran77Parser.Iexpr1Context,i)
[docs]
def PLUS(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.PLUS)
else:
return self.getToken(Fortran77Parser.PLUS, i)
[docs]
def MINUS(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.MINUS)
else:
return self.getToken(Fortran77Parser.MINUS, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_iexpr
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIexpr" ):
listener.enterIexpr(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIexpr" ):
listener.exitIexpr(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIexpr" ):
return visitor.visitIexpr(self)
else:
return visitor.visitChildren(self)
[docs]
def iexpr(self):
localctx = Fortran77Parser.IexprContext(self, self._ctx, self.state)
self.enterRule(localctx, 326, self.RULE_iexpr)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1596
self.iexpr1()
self.state = 1601
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,151,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 1597
_la = self._input.LA(1)
if not(_la==Fortran77Parser.MINUS or _la==Fortran77Parser.PLUS):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 1598
self.iexpr1()
self.state = 1603
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,151,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class IexprCodeContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def iexpr1(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.Iexpr1Context)
else:
return self.getTypedRuleContext(Fortran77Parser.Iexpr1Context,i)
[docs]
def PLUS(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.PLUS)
else:
return self.getToken(Fortran77Parser.PLUS, i)
[docs]
def MINUS(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.MINUS)
else:
return self.getToken(Fortran77Parser.MINUS, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_iexprCode
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIexprCode" ):
listener.enterIexprCode(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIexprCode" ):
listener.exitIexprCode(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIexprCode" ):
return visitor.visitIexprCode(self)
else:
return visitor.visitChildren(self)
[docs]
def iexprCode(self):
localctx = Fortran77Parser.IexprCodeContext(self, self._ctx, self.state)
self.enterRule(localctx, 328, self.RULE_iexprCode)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1604
self.iexpr1()
self.state = 1609
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.MINUS or _la==Fortran77Parser.PLUS:
self.state = 1605
_la = self._input.LA(1)
if not(_la==Fortran77Parser.MINUS or _la==Fortran77Parser.PLUS):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 1606
self.iexpr1()
self.state = 1611
self._errHandler.sync(self)
_la = self._input.LA(1)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Iexpr1Context(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def iexpr2(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.Iexpr2Context)
else:
return self.getTypedRuleContext(Fortran77Parser.Iexpr2Context,i)
[docs]
def STAR(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.STAR)
else:
return self.getToken(Fortran77Parser.STAR, i)
[docs]
def DIV(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.DIV)
else:
return self.getToken(Fortran77Parser.DIV, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_iexpr1
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIexpr1" ):
listener.enterIexpr1(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIexpr1" ):
listener.exitIexpr1(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIexpr1" ):
return visitor.visitIexpr1(self)
else:
return visitor.visitChildren(self)
[docs]
def iexpr1(self):
localctx = Fortran77Parser.Iexpr1Context(self, self._ctx, self.state)
self.enterRule(localctx, 330, self.RULE_iexpr1)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1612
self.iexpr2()
self.state = 1617
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,153,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 1613
_la = self._input.LA(1)
if not(_la==Fortran77Parser.DIV or _la==Fortran77Parser.STAR):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 1614
self.iexpr2()
self.state = 1619
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,153,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Iexpr2Context(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def iexpr3(self):
return self.getTypedRuleContext(Fortran77Parser.Iexpr3Context,0)
[docs]
def PLUS(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.PLUS)
else:
return self.getToken(Fortran77Parser.PLUS, i)
[docs]
def MINUS(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.MINUS)
else:
return self.getToken(Fortran77Parser.MINUS, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_iexpr2
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIexpr2" ):
listener.enterIexpr2(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIexpr2" ):
listener.exitIexpr2(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIexpr2" ):
return visitor.visitIexpr2(self)
else:
return visitor.visitChildren(self)
[docs]
def iexpr2(self):
localctx = Fortran77Parser.Iexpr2Context(self, self._ctx, self.state)
self.enterRule(localctx, 332, self.RULE_iexpr2)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1623
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.MINUS or _la==Fortran77Parser.PLUS:
self.state = 1620
_la = self._input.LA(1)
if not(_la==Fortran77Parser.MINUS or _la==Fortran77Parser.PLUS):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 1625
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 1626
self.iexpr3()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Iexpr3Context(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def iexpr4(self):
return self.getTypedRuleContext(Fortran77Parser.Iexpr4Context,0)
[docs]
def POWER(self):
return self.getToken(Fortran77Parser.POWER, 0)
[docs]
def iexpr3(self):
return self.getTypedRuleContext(Fortran77Parser.Iexpr3Context,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_iexpr3
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIexpr3" ):
listener.enterIexpr3(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIexpr3" ):
listener.exitIexpr3(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIexpr3" ):
return visitor.visitIexpr3(self)
else:
return visitor.visitChildren(self)
[docs]
def iexpr3(self):
localctx = Fortran77Parser.Iexpr3Context(self, self._ctx, self.state)
self.enterRule(localctx, 334, self.RULE_iexpr3)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1628
self.iexpr4()
self.state = 1631
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.POWER:
self.state = 1629
self.match(Fortran77Parser.POWER)
self.state = 1630
self.iexpr3()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Iexpr4Context(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ICON(self):
return self.getToken(Fortran77Parser.ICON, 0)
[docs]
def varRefCode(self):
return self.getTypedRuleContext(Fortran77Parser.VarRefCodeContext,0)
[docs]
def LPAREN(self):
return self.getToken(Fortran77Parser.LPAREN, 0)
[docs]
def iexprCode(self):
return self.getTypedRuleContext(Fortran77Parser.IexprCodeContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran77Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_iexpr4
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIexpr4" ):
listener.enterIexpr4(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIexpr4" ):
listener.exitIexpr4(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIexpr4" ):
return visitor.visitIexpr4(self)
else:
return visitor.visitChildren(self)
[docs]
def iexpr4(self):
localctx = Fortran77Parser.Iexpr4Context(self, self._ctx, self.state)
self.enterRule(localctx, 336, self.RULE_iexpr4)
try:
self.state = 1639
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran77Parser.ICON]:
self.enterOuterAlt(localctx, 1)
self.state = 1633
self.match(Fortran77Parser.ICON)
pass
elif token in [Fortran77Parser.NAME]:
self.enterOuterAlt(localctx, 2)
self.state = 1634
self.varRefCode()
pass
elif token in [Fortran77Parser.LPAREN]:
self.enterOuterAlt(localctx, 3)
self.state = 1635
self.match(Fortran77Parser.LPAREN)
self.state = 1636
self.iexprCode()
self.state = 1637
self.match(Fortran77Parser.RPAREN)
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ConstantExprContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran77Parser.ExpressionContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_constantExpr
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterConstantExpr" ):
listener.enterConstantExpr(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitConstantExpr" ):
listener.exitConstantExpr(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitConstantExpr" ):
return visitor.visitConstantExpr(self)
else:
return visitor.visitChildren(self)
[docs]
def constantExpr(self):
localctx = Fortran77Parser.ConstantExprContext(self, self._ctx, self.state)
self.enterRule(localctx, 338, self.RULE_constantExpr)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1641
self.expression()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ArithmeticExpressionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran77Parser.ExpressionContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_arithmeticExpression
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterArithmeticExpression" ):
listener.enterArithmeticExpression(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitArithmeticExpression" ):
listener.exitArithmeticExpression(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitArithmeticExpression" ):
return visitor.visitArithmeticExpression(self)
else:
return visitor.visitChildren(self)
[docs]
def arithmeticExpression(self):
localctx = Fortran77Parser.ArithmeticExpressionContext(self, self._ctx, self.state)
self.enterRule(localctx, 340, self.RULE_arithmeticExpression)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1643
self.expression()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class IntegerExprContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def iexpr(self):
return self.getTypedRuleContext(Fortran77Parser.IexprContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_integerExpr
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIntegerExpr" ):
listener.enterIntegerExpr(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIntegerExpr" ):
listener.exitIntegerExpr(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIntegerExpr" ):
return visitor.visitIntegerExpr(self)
else:
return visitor.visitChildren(self)
[docs]
def integerExpr(self):
localctx = Fortran77Parser.IntegerExprContext(self, self._ctx, self.state)
self.enterRule(localctx, 342, self.RULE_integerExpr)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1645
self.iexpr()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class IntRealDpExprContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran77Parser.ExpressionContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_intRealDpExpr
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIntRealDpExpr" ):
listener.enterIntRealDpExpr(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIntRealDpExpr" ):
listener.exitIntRealDpExpr(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIntRealDpExpr" ):
return visitor.visitIntRealDpExpr(self)
else:
return visitor.visitChildren(self)
[docs]
def intRealDpExpr(self):
localctx = Fortran77Parser.IntRealDpExprContext(self, self._ctx, self.state)
self.enterRule(localctx, 344, self.RULE_intRealDpExpr)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1647
self.expression()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ArithmeticConstExprContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran77Parser.ExpressionContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_arithmeticConstExpr
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterArithmeticConstExpr" ):
listener.enterArithmeticConstExpr(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitArithmeticConstExpr" ):
listener.exitArithmeticConstExpr(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitArithmeticConstExpr" ):
return visitor.visitArithmeticConstExpr(self)
else:
return visitor.visitChildren(self)
[docs]
def arithmeticConstExpr(self):
localctx = Fortran77Parser.ArithmeticConstExprContext(self, self._ctx, self.state)
self.enterRule(localctx, 346, self.RULE_arithmeticConstExpr)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1649
self.expression()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class IntConstantExprContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran77Parser.ExpressionContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_intConstantExpr
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIntConstantExpr" ):
listener.enterIntConstantExpr(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIntConstantExpr" ):
listener.exitIntConstantExpr(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIntConstantExpr" ):
return visitor.visitIntConstantExpr(self)
else:
return visitor.visitChildren(self)
[docs]
def intConstantExpr(self):
localctx = Fortran77Parser.IntConstantExprContext(self, self._ctx, self.state)
self.enterRule(localctx, 348, self.RULE_intConstantExpr)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1651
self.expression()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class CharacterExpressionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran77Parser.ExpressionContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_characterExpression
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCharacterExpression" ):
listener.enterCharacterExpression(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCharacterExpression" ):
listener.exitCharacterExpression(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCharacterExpression" ):
return visitor.visitCharacterExpression(self)
else:
return visitor.visitChildren(self)
[docs]
def characterExpression(self):
localctx = Fortran77Parser.CharacterExpressionContext(self, self._ctx, self.state)
self.enterRule(localctx, 350, self.RULE_characterExpression)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1653
self.expression()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ConcatOpContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def DIV(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.DIV)
else:
return self.getToken(Fortran77Parser.DIV, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_concatOp
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterConcatOp" ):
listener.enterConcatOp(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitConcatOp" ):
listener.exitConcatOp(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitConcatOp" ):
return visitor.visitConcatOp(self)
else:
return visitor.visitChildren(self)
[docs]
def concatOp(self):
localctx = Fortran77Parser.ConcatOpContext(self, self._ctx, self.state)
self.enterRule(localctx, 352, self.RULE_concatOp)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1655
self.match(Fortran77Parser.DIV)
self.state = 1656
self.match(Fortran77Parser.DIV)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class LogicalExpressionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran77Parser.ExpressionContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_logicalExpression
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLogicalExpression" ):
listener.enterLogicalExpression(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLogicalExpression" ):
listener.exitLogicalExpression(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLogicalExpression" ):
return visitor.visitLogicalExpression(self)
else:
return visitor.visitChildren(self)
[docs]
def logicalExpression(self):
localctx = Fortran77Parser.LogicalExpressionContext(self, self._ctx, self.state)
self.enterRule(localctx, 354, self.RULE_logicalExpression)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1658
self.expression()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class LogicalConstExprContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran77Parser.ExpressionContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_logicalConstExpr
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLogicalConstExpr" ):
listener.enterLogicalConstExpr(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLogicalConstExpr" ):
listener.exitLogicalConstExpr(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLogicalConstExpr" ):
return visitor.visitLogicalConstExpr(self)
else:
return visitor.visitChildren(self)
[docs]
def logicalConstExpr(self):
localctx = Fortran77Parser.LogicalConstExprContext(self, self._ctx, self.state)
self.enterRule(localctx, 356, self.RULE_logicalConstExpr)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1660
self.expression()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ArrayElementNameContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def NAME(self):
return self.getToken(Fortran77Parser.NAME, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran77Parser.LPAREN, 0)
[docs]
def integerExpr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.IntegerExprContext)
else:
return self.getTypedRuleContext(Fortran77Parser.IntegerExprContext,i)
[docs]
def RPAREN(self):
return self.getToken(Fortran77Parser.RPAREN, 0)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.COMMA)
else:
return self.getToken(Fortran77Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_arrayElementName
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterArrayElementName" ):
listener.enterArrayElementName(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitArrayElementName" ):
listener.exitArrayElementName(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitArrayElementName" ):
return visitor.visitArrayElementName(self)
else:
return visitor.visitChildren(self)
[docs]
def arrayElementName(self):
localctx = Fortran77Parser.ArrayElementNameContext(self, self._ctx, self.state)
self.enterRule(localctx, 358, self.RULE_arrayElementName)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1662
self.match(Fortran77Parser.NAME)
self.state = 1663
self.match(Fortran77Parser.LPAREN)
self.state = 1664
self.integerExpr()
self.state = 1669
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.COMMA:
self.state = 1665
self.match(Fortran77Parser.COMMA)
self.state = 1666
self.integerExpr()
self.state = 1671
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 1672
self.match(Fortran77Parser.RPAREN)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class SubscriptsContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def LPAREN(self):
return self.getToken(Fortran77Parser.LPAREN, 0)
[docs]
def RPAREN(self):
return self.getToken(Fortran77Parser.RPAREN, 0)
[docs]
def expression(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.ExpressionContext)
else:
return self.getTypedRuleContext(Fortran77Parser.ExpressionContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.COMMA)
else:
return self.getToken(Fortran77Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_subscripts
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSubscripts" ):
listener.enterSubscripts(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSubscripts" ):
listener.exitSubscripts(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSubscripts" ):
return visitor.visitSubscripts(self)
else:
return visitor.visitChildren(self)
[docs]
def subscripts(self):
localctx = Fortran77Parser.SubscriptsContext(self, self._ctx, self.state)
self.enterRule(localctx, 360, self.RULE_subscripts)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1674
self.match(Fortran77Parser.LPAREN)
self.state = 1683
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.REAL or ((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & ((1 << (Fortran77Parser.LPAREN - 70)) | (1 << (Fortran77Parser.MINUS - 70)) | (1 << (Fortran77Parser.PLUS - 70)) | (1 << (Fortran77Parser.LNOT - 70)) | (1 << (Fortran77Parser.TRUE - 70)) | (1 << (Fortran77Parser.FALSE - 70)) | (1 << (Fortran77Parser.HOLLERITH - 70)) | (1 << (Fortran77Parser.SCON - 70)) | (1 << (Fortran77Parser.RCON - 70)) | (1 << (Fortran77Parser.ICON - 70)) | (1 << (Fortran77Parser.NAME - 70)))) != 0):
self.state = 1675
self.expression()
self.state = 1680
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran77Parser.COMMA:
self.state = 1676
self.match(Fortran77Parser.COMMA)
self.state = 1677
self.expression()
self.state = 1682
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 1685
self.match(Fortran77Parser.RPAREN)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class VarRefContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def NAME(self):
return self.getToken(Fortran77Parser.NAME, 0)
[docs]
def REAL(self):
return self.getToken(Fortran77Parser.REAL, 0)
[docs]
def subscripts(self):
return self.getTypedRuleContext(Fortran77Parser.SubscriptsContext,0)
[docs]
def substringApp(self):
return self.getTypedRuleContext(Fortran77Parser.SubstringAppContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_varRef
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterVarRef" ):
listener.enterVarRef(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitVarRef" ):
listener.exitVarRef(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitVarRef" ):
return visitor.visitVarRef(self)
else:
return visitor.visitChildren(self)
[docs]
def varRef(self):
localctx = Fortran77Parser.VarRefContext(self, self._ctx, self.state)
self.enterRule(localctx, 362, self.RULE_varRef)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1687
_la = self._input.LA(1)
if not(_la==Fortran77Parser.REAL or _la==Fortran77Parser.NAME):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 1692
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,161,self._ctx)
if la_ == 1:
self.state = 1688
self.subscripts()
self.state = 1690
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,160,self._ctx)
if la_ == 1:
self.state = 1689
self.substringApp()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class VarRefCodeContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def NAME(self):
return self.getToken(Fortran77Parser.NAME, 0)
[docs]
def subscripts(self):
return self.getTypedRuleContext(Fortran77Parser.SubscriptsContext,0)
[docs]
def substringApp(self):
return self.getTypedRuleContext(Fortran77Parser.SubstringAppContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_varRefCode
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterVarRefCode" ):
listener.enterVarRefCode(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitVarRefCode" ):
listener.exitVarRefCode(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitVarRefCode" ):
return visitor.visitVarRefCode(self)
else:
return visitor.visitChildren(self)
[docs]
def varRefCode(self):
localctx = Fortran77Parser.VarRefCodeContext(self, self._ctx, self.state)
self.enterRule(localctx, 364, self.RULE_varRefCode)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1694
self.match(Fortran77Parser.NAME)
self.state = 1699
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,163,self._ctx)
if la_ == 1:
self.state = 1695
self.subscripts()
self.state = 1697
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,162,self._ctx)
if la_ == 1:
self.state = 1696
self.substringApp()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class SubstringAppContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def LPAREN(self):
return self.getToken(Fortran77Parser.LPAREN, 0)
[docs]
def COLON(self):
return self.getToken(Fortran77Parser.COLON, 0)
[docs]
def RPAREN(self):
return self.getToken(Fortran77Parser.RPAREN, 0)
[docs]
def ncExpr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran77Parser.NcExprContext)
else:
return self.getTypedRuleContext(Fortran77Parser.NcExprContext,i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_substringApp
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSubstringApp" ):
listener.enterSubstringApp(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSubstringApp" ):
listener.exitSubstringApp(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSubstringApp" ):
return visitor.visitSubstringApp(self)
else:
return visitor.visitChildren(self)
[docs]
def substringApp(self):
localctx = Fortran77Parser.SubstringAppContext(self, self._ctx, self.state)
self.enterRule(localctx, 366, self.RULE_substringApp)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1701
self.match(Fortran77Parser.LPAREN)
self.state = 1703
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.REAL or ((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & ((1 << (Fortran77Parser.LPAREN - 70)) | (1 << (Fortran77Parser.MINUS - 70)) | (1 << (Fortran77Parser.PLUS - 70)) | (1 << (Fortran77Parser.LNOT - 70)) | (1 << (Fortran77Parser.TRUE - 70)) | (1 << (Fortran77Parser.FALSE - 70)) | (1 << (Fortran77Parser.HOLLERITH - 70)) | (1 << (Fortran77Parser.SCON - 70)) | (1 << (Fortran77Parser.RCON - 70)) | (1 << (Fortran77Parser.ICON - 70)) | (1 << (Fortran77Parser.NAME - 70)))) != 0):
self.state = 1702
self.ncExpr()
self.state = 1705
self.match(Fortran77Parser.COLON)
self.state = 1707
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.REAL or ((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & ((1 << (Fortran77Parser.LPAREN - 70)) | (1 << (Fortran77Parser.MINUS - 70)) | (1 << (Fortran77Parser.PLUS - 70)) | (1 << (Fortran77Parser.LNOT - 70)) | (1 << (Fortran77Parser.TRUE - 70)) | (1 << (Fortran77Parser.FALSE - 70)) | (1 << (Fortran77Parser.HOLLERITH - 70)) | (1 << (Fortran77Parser.SCON - 70)) | (1 << (Fortran77Parser.RCON - 70)) | (1 << (Fortran77Parser.ICON - 70)) | (1 << (Fortran77Parser.NAME - 70)))) != 0):
self.state = 1706
self.ncExpr()
self.state = 1709
self.match(Fortran77Parser.RPAREN)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class VariableNameContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def NAME(self):
return self.getToken(Fortran77Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_variableName
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterVariableName" ):
listener.enterVariableName(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitVariableName" ):
listener.exitVariableName(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitVariableName" ):
return visitor.visitVariableName(self)
else:
return visitor.visitChildren(self)
[docs]
def variableName(self):
localctx = Fortran77Parser.VariableNameContext(self, self._ctx, self.state)
self.enterRule(localctx, 368, self.RULE_variableName)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1711
self.match(Fortran77Parser.NAME)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ArrayNameContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def NAME(self):
return self.getToken(Fortran77Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_arrayName
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterArrayName" ):
listener.enterArrayName(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitArrayName" ):
listener.exitArrayName(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitArrayName" ):
return visitor.visitArrayName(self)
else:
return visitor.visitChildren(self)
[docs]
def arrayName(self):
localctx = Fortran77Parser.ArrayNameContext(self, self._ctx, self.state)
self.enterRule(localctx, 370, self.RULE_arrayName)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1713
self.match(Fortran77Parser.NAME)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class SubroutineNameContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def NAME(self):
return self.getToken(Fortran77Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_subroutineName
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSubroutineName" ):
listener.enterSubroutineName(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSubroutineName" ):
listener.exitSubroutineName(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSubroutineName" ):
return visitor.visitSubroutineName(self)
else:
return visitor.visitChildren(self)
[docs]
def subroutineName(self):
localctx = Fortran77Parser.SubroutineNameContext(self, self._ctx, self.state)
self.enterRule(localctx, 372, self.RULE_subroutineName)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1715
self.match(Fortran77Parser.NAME)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class FunctionNameContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def NAME(self):
return self.getToken(Fortran77Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_functionName
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterFunctionName" ):
listener.enterFunctionName(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitFunctionName" ):
listener.exitFunctionName(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFunctionName" ):
return visitor.visitFunctionName(self)
else:
return visitor.visitChildren(self)
[docs]
def functionName(self):
localctx = Fortran77Parser.FunctionNameContext(self, self._ctx, self.state)
self.enterRule(localctx, 374, self.RULE_functionName)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1717
self.match(Fortran77Parser.NAME)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ConstantContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def unsignedArithmeticConstant(self):
return self.getTypedRuleContext(Fortran77Parser.UnsignedArithmeticConstantContext,0)
[docs]
def PLUS(self):
return self.getToken(Fortran77Parser.PLUS, 0)
[docs]
def MINUS(self):
return self.getToken(Fortran77Parser.MINUS, 0)
[docs]
def SCON(self):
return self.getToken(Fortran77Parser.SCON, 0)
[docs]
def HOLLERITH(self):
return self.getToken(Fortran77Parser.HOLLERITH, 0)
[docs]
def logicalConstant(self):
return self.getTypedRuleContext(Fortran77Parser.LogicalConstantContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_constant
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterConstant" ):
listener.enterConstant(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitConstant" ):
listener.exitConstant(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitConstant" ):
return visitor.visitConstant(self)
else:
return visitor.visitChildren(self)
[docs]
def constant(self):
localctx = Fortran77Parser.ConstantContext(self, self._ctx, self.state)
self.enterRule(localctx, 376, self.RULE_constant)
self._la = 0 # Token type
try:
self.state = 1725
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran77Parser.LPAREN, Fortran77Parser.MINUS, Fortran77Parser.PLUS, Fortran77Parser.RCON, Fortran77Parser.ICON]:
self.enterOuterAlt(localctx, 1)
self.state = 1720
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.MINUS or _la==Fortran77Parser.PLUS:
self.state = 1719
_la = self._input.LA(1)
if not(_la==Fortran77Parser.MINUS or _la==Fortran77Parser.PLUS):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 1722
self.unsignedArithmeticConstant()
pass
elif token in [Fortran77Parser.HOLLERITH, Fortran77Parser.SCON]:
self.enterOuterAlt(localctx, 2)
self.state = 1723
_la = self._input.LA(1)
if not(_la==Fortran77Parser.HOLLERITH or _la==Fortran77Parser.SCON):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
pass
elif token in [Fortran77Parser.TRUE, Fortran77Parser.FALSE]:
self.enterOuterAlt(localctx, 3)
self.state = 1724
self.logicalConstant()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class UnsignedArithmeticConstantContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ICON(self):
return self.getToken(Fortran77Parser.ICON, 0)
[docs]
def RCON(self):
return self.getToken(Fortran77Parser.RCON, 0)
[docs]
def complexConstant(self):
return self.getTypedRuleContext(Fortran77Parser.ComplexConstantContext,0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_unsignedArithmeticConstant
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterUnsignedArithmeticConstant" ):
listener.enterUnsignedArithmeticConstant(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitUnsignedArithmeticConstant" ):
listener.exitUnsignedArithmeticConstant(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitUnsignedArithmeticConstant" ):
return visitor.visitUnsignedArithmeticConstant(self)
else:
return visitor.visitChildren(self)
[docs]
def unsignedArithmeticConstant(self):
localctx = Fortran77Parser.UnsignedArithmeticConstantContext(self, self._ctx, self.state)
self.enterRule(localctx, 378, self.RULE_unsignedArithmeticConstant)
self._la = 0 # Token type
try:
self.state = 1729
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran77Parser.RCON, Fortran77Parser.ICON]:
self.enterOuterAlt(localctx, 1)
self.state = 1727
_la = self._input.LA(1)
if not(_la==Fortran77Parser.RCON or _la==Fortran77Parser.ICON):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
pass
elif token in [Fortran77Parser.LPAREN]:
self.enterOuterAlt(localctx, 2)
self.state = 1728
self.complexConstant()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ComplexConstantContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def LPAREN(self):
return self.getToken(Fortran77Parser.LPAREN, 0)
[docs]
def COMMA(self):
return self.getToken(Fortran77Parser.COMMA, 0)
[docs]
def RPAREN(self):
return self.getToken(Fortran77Parser.RPAREN, 0)
[docs]
def ICON(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.ICON)
else:
return self.getToken(Fortran77Parser.ICON, i)
[docs]
def RCON(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.RCON)
else:
return self.getToken(Fortran77Parser.RCON, i)
[docs]
def PLUS(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.PLUS)
else:
return self.getToken(Fortran77Parser.PLUS, i)
[docs]
def MINUS(self, i:int=None):
if i is None:
return self.getTokens(Fortran77Parser.MINUS)
else:
return self.getToken(Fortran77Parser.MINUS, i)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_complexConstant
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterComplexConstant" ):
listener.enterComplexConstant(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitComplexConstant" ):
listener.exitComplexConstant(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitComplexConstant" ):
return visitor.visitComplexConstant(self)
else:
return visitor.visitChildren(self)
[docs]
def complexConstant(self):
localctx = Fortran77Parser.ComplexConstantContext(self, self._ctx, self.state)
self.enterRule(localctx, 380, self.RULE_complexConstant)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1731
self.match(Fortran77Parser.LPAREN)
self.state = 1733
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.MINUS or _la==Fortran77Parser.PLUS:
self.state = 1732
_la = self._input.LA(1)
if not(_la==Fortran77Parser.MINUS or _la==Fortran77Parser.PLUS):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 1735
_la = self._input.LA(1)
if not(_la==Fortran77Parser.RCON or _la==Fortran77Parser.ICON):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 1736
self.match(Fortran77Parser.COMMA)
self.state = 1738
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran77Parser.MINUS or _la==Fortran77Parser.PLUS:
self.state = 1737
_la = self._input.LA(1)
if not(_la==Fortran77Parser.MINUS or _la==Fortran77Parser.PLUS):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 1740
_la = self._input.LA(1)
if not(_la==Fortran77Parser.RCON or _la==Fortran77Parser.ICON):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 1741
self.match(Fortran77Parser.RPAREN)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class LogicalConstantContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def TRUE(self):
return self.getToken(Fortran77Parser.TRUE, 0)
[docs]
def FALSE(self):
return self.getToken(Fortran77Parser.FALSE, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_logicalConstant
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLogicalConstant" ):
listener.enterLogicalConstant(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLogicalConstant" ):
listener.exitLogicalConstant(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLogicalConstant" ):
return visitor.visitLogicalConstant(self)
else:
return visitor.visitChildren(self)
[docs]
def logicalConstant(self):
localctx = Fortran77Parser.LogicalConstantContext(self, self._ctx, self.state)
self.enterRule(localctx, 382, self.RULE_logicalConstant)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1743
_la = self._input.LA(1)
if not(_la==Fortran77Parser.TRUE or _la==Fortran77Parser.FALSE):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class IdentifierContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def NAME(self):
return self.getToken(Fortran77Parser.NAME, 0)
[docs]
def REAL(self):
return self.getToken(Fortran77Parser.REAL, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_identifier
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIdentifier" ):
listener.enterIdentifier(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIdentifier" ):
listener.exitIdentifier(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIdentifier" ):
return visitor.visitIdentifier(self)
else:
return visitor.visitChildren(self)
[docs]
def identifier(self):
localctx = Fortran77Parser.IdentifierContext(self, self._ctx, self.state)
self.enterRule(localctx, 384, self.RULE_identifier)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1745
_la = self._input.LA(1)
if not(_la==Fortran77Parser.REAL or _la==Fortran77Parser.NAME):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ToContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def NAME(self):
return self.getToken(Fortran77Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran77Parser.RULE_to
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTo" ):
listener.enterTo(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTo" ):
listener.exitTo(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTo" ):
return visitor.visitTo(self)
else:
return visitor.visitChildren(self)
[docs]
def to(self):
localctx = Fortran77Parser.ToContext(self, self._ctx, self.state)
self.enterRule(localctx, 386, self.RULE_to)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1747
self.match(Fortran77Parser.NAME)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx