# Generated from Fortran90Parser.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\u00c5")
buf.write("\u0e88\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\4\u00c4\t\u00c4\4\u00c5\t\u00c5\4\u00c6\t\u00c6")
buf.write("\4\u00c7\t\u00c7\4\u00c8\t\u00c8\4\u00c9\t\u00c9\4\u00ca")
buf.write("\t\u00ca\4\u00cb\t\u00cb\4\u00cc\t\u00cc\4\u00cd\t\u00cd")
buf.write("\4\u00ce\t\u00ce\4\u00cf\t\u00cf\4\u00d0\t\u00d0\4\u00d1")
buf.write("\t\u00d1\4\u00d2\t\u00d2\4\u00d3\t\u00d3\4\u00d4\t\u00d4")
buf.write("\4\u00d5\t\u00d5\4\u00d6\t\u00d6\4\u00d7\t\u00d7\4\u00d8")
buf.write("\t\u00d8\4\u00d9\t\u00d9\4\u00da\t\u00da\4\u00db\t\u00db")
buf.write("\4\u00dc\t\u00dc\4\u00dd\t\u00dd\4\u00de\t\u00de\4\u00df")
buf.write("\t\u00df\4\u00e0\t\u00e0\4\u00e1\t\u00e1\4\u00e2\t\u00e2")
buf.write("\4\u00e3\t\u00e3\4\u00e4\t\u00e4\4\u00e5\t\u00e5\4\u00e6")
buf.write("\t\u00e6\4\u00e7\t\u00e7\4\u00e8\t\u00e8\4\u00e9\t\u00e9")
buf.write("\4\u00ea\t\u00ea\4\u00eb\t\u00eb\4\u00ec\t\u00ec\4\u00ed")
buf.write("\t\u00ed\4\u00ee\t\u00ee\4\u00ef\t\u00ef\4\u00f0\t\u00f0")
buf.write("\4\u00f1\t\u00f1\4\u00f2\t\u00f2\4\u00f3\t\u00f3\4\u00f4")
buf.write("\t\u00f4\4\u00f5\t\u00f5\4\u00f6\t\u00f6\4\u00f7\t\u00f7")
buf.write("\4\u00f8\t\u00f8\4\u00f9\t\u00f9\4\u00fa\t\u00fa\4\u00fb")
buf.write("\t\u00fb\4\u00fc\t\u00fc\4\u00fd\t\u00fd\4\u00fe\t\u00fe")
buf.write("\4\u00ff\t\u00ff\4\u0100\t\u0100\4\u0101\t\u0101\4\u0102")
buf.write("\t\u0102\4\u0103\t\u0103\4\u0104\t\u0104\4\u0105\t\u0105")
buf.write("\4\u0106\t\u0106\4\u0107\t\u0107\4\u0108\t\u0108\4\u0109")
buf.write("\t\u0109\4\u010a\t\u010a\4\u010b\t\u010b\4\u010c\t\u010c")
buf.write("\4\u010d\t\u010d\4\u010e\t\u010e\4\u010f\t\u010f\4\u0110")
buf.write("\t\u0110\4\u0111\t\u0111\4\u0112\t\u0112\4\u0113\t\u0113")
buf.write("\4\u0114\t\u0114\4\u0115\t\u0115\4\u0116\t\u0116\4\u0117")
buf.write("\t\u0117\4\u0118\t\u0118\4\u0119\t\u0119\4\u011a\t\u011a")
buf.write("\4\u011b\t\u011b\4\u011c\t\u011c\4\u011d\t\u011d\4\u011e")
buf.write("\t\u011e\4\u011f\t\u011f\4\u0120\t\u0120\4\u0121\t\u0121")
buf.write("\4\u0122\t\u0122\4\u0123\t\u0123\4\u0124\t\u0124\4\u0125")
buf.write("\t\u0125\4\u0126\t\u0126\4\u0127\t\u0127\4\u0128\t\u0128")
buf.write("\4\u0129\t\u0129\4\u012a\t\u012a\4\u012b\t\u012b\4\u012c")
buf.write("\t\u012c\4\u012d\t\u012d\4\u012e\t\u012e\4\u012f\t\u012f")
buf.write("\4\u0130\t\u0130\4\u0131\t\u0131\4\u0132\t\u0132\4\u0133")
buf.write("\t\u0133\4\u0134\t\u0134\4\u0135\t\u0135\4\u0136\t\u0136")
buf.write("\4\u0137\t\u0137\4\u0138\t\u0138\4\u0139\t\u0139\4\u013a")
buf.write("\t\u013a\4\u013b\t\u013b\4\u013c\t\u013c\4\u013d\t\u013d")
buf.write("\4\u013e\t\u013e\4\u013f\t\u013f\4\u0140\t\u0140\4\u0141")
buf.write("\t\u0141\4\u0142\t\u0142\4\u0143\t\u0143\4\u0144\t\u0144")
buf.write("\4\u0145\t\u0145\4\u0146\t\u0146\4\u0147\t\u0147\4\u0148")
buf.write("\t\u0148\4\u0149\t\u0149\4\u014a\t\u014a\4\u014b\t\u014b")
buf.write("\4\u014c\t\u014c\4\u014d\t\u014d\4\u014e\t\u014e\4\u014f")
buf.write("\t\u014f\4\u0150\t\u0150\4\u0151\t\u0151\4\u0152\t\u0152")
buf.write("\4\u0153\t\u0153\4\u0154\t\u0154\4\u0155\t\u0155\4\u0156")
buf.write("\t\u0156\4\u0157\t\u0157\4\u0158\t\u0158\4\u0159\t\u0159")
buf.write("\4\u015a\t\u015a\4\u015b\t\u015b\4\u015c\t\u015c\4\u015d")
buf.write("\t\u015d\3\2\3\2\3\3\6\3\u02be\n\3\r\3\16\3\u02bf\3\4")
buf.write("\3\4\3\4\3\4\3\4\5\4\u02c7\n\4\3\5\5\5\u02ca\n\5\3\5\3")
buf.write("\5\3\6\3\6\3\6\3\7\5\7\u02d2\n\7\3\7\3\7\3\7\3\7\5\7\u02d8")
buf.write("\n\7\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\5\b\u02e2\n\b\3\b")
buf.write("\3\b\7\b\u02e6\n\b\f\b\16\b\u02e9\13\b\3\t\3\t\5\t\u02ed")
buf.write("\n\t\3\n\3\n\3\n\3\n\3\n\3\n\3\n\5\n\u02f6\n\n\3\13\3")
buf.write("\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13")
buf.write("\3\13\3\13\3\13\3\13\3\13\5\13\u0309\n\13\3\f\3\f\3\f")
buf.write("\7\f\u030e\n\f\f\f\16\f\u0311\13\f\3\r\3\r\3\r\3\r\3\r")
buf.write("\3\r\5\r\u0319\n\r\3\16\3\16\3\16\7\16\u031e\n\16\f\16")
buf.write("\16\16\u0321\13\16\3\17\3\17\3\17\3\17\3\20\3\20\3\21")
buf.write("\3\21\3\21\3\21\3\21\3\22\6\22\u032f\n\22\r\22\16\22\u0330")
buf.write("\3\23\3\23\3\23\3\23\3\24\3\24\3\24\3\24\5\24\u033b\n")
buf.write("\24\5\24\u033d\n\24\3\25\3\25\3\25\3\25\3\25\3\25\3\25")
buf.write("\5\25\u0346\n\25\3\26\3\26\5\26\u034a\n\26\3\26\3\26\3")
buf.write("\26\5\26\u034f\n\26\5\26\u0351\n\26\3\27\3\27\3\27\3\27")
buf.write("\3\27\7\27\u0358\n\27\f\27\16\27\u035b\13\27\3\30\3\30")
buf.write("\3\31\3\31\5\31\u0361\n\31\3\31\3\31\3\31\5\31\u0366\n")
buf.write("\31\3\31\3\31\3\31\5\31\u036b\n\31\3\31\3\31\3\31\3\31")
buf.write("\5\31\u0371\n\31\3\31\5\31\u0374\n\31\3\32\3\32\3\32\3")
buf.write("\32\5\32\u037a\n\32\3\32\3\32\3\33\3\33\3\33\3\33\3\33")
buf.write("\5\33\u0383\n\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3")
buf.write("\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\7\33\u0394\n\33")
buf.write("\f\33\16\33\u0397\13\33\3\34\3\34\3\34\3\34\3\34\3\34")
buf.write("\3\34\3\34\3\34\3\34\5\34\u03a3\n\34\3\35\3\35\3\35\3")
buf.write("\35\3\35\3\35\3\35\3\35\3\35\5\35\u03ae\n\35\3\36\3\36")
buf.write("\3\36\3\36\3\36\3\36\3\36\3\36\5\36\u03b8\n\36\3\37\3")
buf.write("\37\3\37\3\37\3\37\3\37\3\37\5\37\u03c1\n\37\3 \3 \3 ")
buf.write("\5 \u03c6\n \3 \3 \5 \u03ca\n \3 \5 \u03cd\n \3!\3!\3")
buf.write("!\3!\3!\3!\3!\3!\3\"\3\"\5\"\u03d9\n\"\3\"\5\"\u03dc\n")
buf.write("\"\3#\3#\3#\7#\u03e1\n#\f#\16#\u03e4\13#\3$\3$\5$\u03e8")
buf.write("\n$\3%\3%\3%\3%\5%\u03ee\n%\3&\3&\3&\3&\3&\3&\3&\3&\3")
buf.write("&\3&\3&\3&\3&\3&\5&\u03fe\n&\3\'\3\'\5\'\u0402\n\'\3\'")
buf.write("\3\'\3(\3(\3(\7(\u0409\n(\f(\16(\u040c\13(\3)\3)\3)\3")
buf.write(")\3)\3)\5)\u0414\n)\3*\3*\5*\u0418\n*\3*\3*\3+\3+\3+\7")
buf.write("+\u041f\n+\f+\16+\u0422\13+\3,\3,\3,\3,\3,\3,\5,\u042a")
buf.write("\n,\3-\3-\5-\u042e\n-\3-\3-\3.\3.\3.\7.\u0435\n.\f.\16")
buf.write(".\u0438\13.\3/\3/\3\60\3\60\3\60\3\61\3\61\3\61\3\61\3")
buf.write("\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61")
buf.write("\3\61\3\61\3\61\3\61\3\61\3\61\3\61\7\61\u0455\n\61\f")
buf.write("\61\16\61\u0458\13\61\3\62\3\62\3\63\3\63\3\64\3\64\3")
buf.write("\64\3\64\3\64\5\64\u0463\n\64\3\64\3\64\3\65\3\65\3\65")
buf.write("\3\65\3\66\3\66\3\67\3\67\38\38\39\39\59\u0473\n9\39\3")
buf.write("9\3:\3:\3:\7:\u047a\n:\f:\16:\u047d\13:\3;\3;\3;\3;\3")
buf.write(";\3;\5;\u0485\n;\3<\3<\3=\3=\5=\u048b\n=\3=\3=\5=\u048f")
buf.write("\n=\3>\3>\3>\7>\u0494\n>\f>\16>\u0497\13>\3?\3?\5?\u049b")
buf.write("\n?\3@\3@\3A\3A\3A\3A\3A\3A\5A\u04a5\nA\3B\6B\u04a8\n")
buf.write("B\rB\16B\u04a9\3C\3C\5C\u04ae\nC\3D\3D\3D\3D\3E\3E\3E")
buf.write("\3F\6F\u04b8\nF\rF\16F\u04b9\3G\3G\3H\3H\3H\3I\6I\u04c2")
buf.write("\nI\rI\16I\u04c3\3J\3J\3K\3K\3K\3L\6L\u04cc\nL\rL\16L")
buf.write("\u04cd\3M\3M\3M\3M\3M\3M\3N\3N\3O\6O\u04d9\nO\rO\16O\u04da")
buf.write("\3P\3P\3P\3P\3P\5P\u04e2\nP\3Q\6Q\u04e5\nQ\rQ\16Q\u04e6")
buf.write("\3R\3R\3R\3S\3S\5S\u04ee\nS\3S\3S\3S\3S\3S\5S\u04f5\n")
buf.write("S\3S\3S\3S\3S\3S\7S\u04fc\nS\fS\16S\u04ff\13S\3T\3T\5")
buf.write("T\u0503\nT\3U\3U\3U\3U\3U\3V\3V\3V\3V\3V\3V\3V\3V\5V\u0512")
buf.write("\nV\3W\3W\3X\3X\3X\3X\3X\5X\u051b\nX\3X\3X\3X\5X\u0520")
buf.write("\nX\3Y\3Y\3Y\3Y\3Y\3Y\3Y\7Y\u0529\nY\fY\16Y\u052c\13Y")
buf.write("\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3")
buf.write("Z\3Z\5Z\u0541\nZ\3[\3[\3[\7[\u0546\n[\f[\16[\u0549\13")
buf.write("[\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\")
buf.write("\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3")
buf.write("\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\")
buf.write("\3\\\3\\\3\\\5\\\u0576\n\\\3]\3]\3^\3^\3^\3^\5^\u057e")
buf.write("\n^\3_\3_\3_\3_\3_\3_\3_\3_\3_\5_\u0589\n_\3_\3_\3_\7")
buf.write("_\u058e\n_\f_\16_\u0591\13_\3`\3`\3`\3`\5`\u0597\n`\3")
buf.write("a\3a\3a\3a\3a\3a\3a\3a\3a\3a\3a\3a\3a\3a\3a\5a\u05a8\n")
buf.write("a\3b\3b\3b\3b\3c\3c\3c\5c\u05b1\nc\3c\5c\u05b4\nc\3d\3")
buf.write("d\3d\3d\3d\5d\u05bb\nd\3e\3e\3e\3e\3e\3e\3e\3e\3e\5e\u05c6")
buf.write("\ne\3f\3f\3f\3f\3f\3f\3f\3f\3f\3f\3f\3f\3f\5f\u05d5\n")
buf.write("f\3g\3g\3g\3g\3g\7g\u05dc\ng\fg\16g\u05df\13g\3h\3h\5")
buf.write("h\u05e3\nh\3i\3i\3i\3i\3j\3j\3j\7j\u05ec\nj\fj\16j\u05ef")
buf.write("\13j\3k\3k\3l\3l\3l\3l\3l\3l\3l\5l\u05fa\nl\3m\3m\5m\u05fe")
buf.write("\nm\3m\3m\3n\3n\3n\3n\5n\u0606\nn\5n\u0608\nn\3o\3o\3")
buf.write("p\5p\u060d\np\3p\5p\u0610\np\3p\3p\3p\3p\3p\5p\u0617\n")
buf.write("p\3q\3q\5q\u061b\nq\3q\3q\3r\3r\5r\u0621\nr\3r\3r\3s\3")
buf.write("s\3s\7s\u0628\ns\fs\16s\u062b\13s\3t\3t\3u\3u\3u\3u\3")
buf.write("u\7u\u0634\nu\fu\16u\u0637\13u\3v\3v\3v\3v\5v\u063d\n")
buf.write("v\5v\u063f\nv\3w\3w\3w\3w\3x\3x\3x\3x\3x\3x\3x\3x\5x\u064d")
buf.write("\nx\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\5y\u0659\ny\3z\3z\3")
buf.write("z\3z\3z\7z\u0660\nz\fz\16z\u0663\13z\3{\3{\5{\u0667\n")
buf.write("{\3|\3|\3}\3}\3}\3}\3}\3}\3}\3}\3}\3}\3}\3}\3}\5}\u0678")
buf.write("\n}\3~\3~\3~\7~\u067d\n~\f~\16~\u0680\13~\3\177\3\177")
buf.write("\3\177\3\177\3\177\3\177\3\177\3\177\3\177\3\177\3\177")
buf.write("\3\177\3\177\3\177\3\177\3\177\3\177\3\177\3\177\3\177")
buf.write("\3\177\3\177\3\177\3\177\3\177\3\177\3\177\3\177\3\177")
buf.write("\3\177\3\177\3\177\3\177\3\177\3\177\3\177\3\177\3\177")
buf.write("\3\177\3\177\3\177\3\177\3\177\5\177\u06ad\n\177\3\u0080")
buf.write("\3\u0080\3\u0081\3\u0081\3\u0081\7\u0081\u06b4\n\u0081")
buf.write("\f\u0081\16\u0081\u06b7\13\u0081\3\u0082\3\u0082\3\u0082")
buf.write("\3\u0082\3\u0082\3\u0082\5\u0082\u06bf\n\u0082\3\u0083")
buf.write("\3\u0083\5\u0083\u06c3\n\u0083\3\u0084\3\u0084\3\u0084")
buf.write("\7\u0084\u06c8\n\u0084\f\u0084\16\u0084\u06cb\13\u0084")
buf.write("\3\u0085\3\u0085\3\u0085\3\u0085\3\u0085\5\u0085\u06d2")
buf.write("\n\u0085\3\u0086\3\u0086\3\u0087\3\u0087\3\u0088\3\u0088")
buf.write("\3\u0088\7\u0088\u06db\n\u0088\f\u0088\16\u0088\u06de")
buf.write("\13\u0088\3\u0089\3\u0089\3\u008a\3\u008a\3\u008a\3\u008a")
buf.write("\3\u008a\3\u008a\3\u008a\3\u008a\3\u008a\3\u008a\3\u008a")
buf.write("\3\u008a\3\u008a\3\u008a\3\u008a\3\u008a\3\u008a\3\u008a")
buf.write("\3\u008a\3\u008a\3\u008a\3\u008a\3\u008a\3\u008a\3\u008a")
buf.write("\5\u008a\u06fb\n\u008a\3\u008b\3\u008b\3\u008b\3\u008b")
buf.write("\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b\5\u008b")
buf.write("\u0707\n\u008b\3\u008c\3\u008c\3\u008d\3\u008d\3\u008d")
buf.write("\3\u008d\3\u008d\3\u008d\3\u008d\3\u008d\3\u008d\3\u008d")
buf.write("\3\u008d\3\u008d\3\u008d\3\u008d\3\u008d\3\u008d\3\u008d")
buf.write("\3\u008d\3\u008d\3\u008d\3\u008d\3\u008d\3\u008d\3\u008d")
buf.write("\3\u008d\3\u008d\3\u008d\3\u008d\3\u008d\3\u008d\3\u008d")
buf.write("\3\u008d\3\u008d\3\u008d\5\u008d\u072d\n\u008d\3\u008e")
buf.write("\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e\5\u008e\u0735")
buf.write("\n\u008e\3\u008f\3\u008f\3\u008f\3\u008f\3\u008f\5\u008f")
buf.write("\u073c\n\u008f\3\u0090\3\u0090\5\u0090\u0740\n\u0090\3")
buf.write("\u0090\3\u0090\3\u0090\3\u0090\3\u0090\3\u0090\3\u0090")
buf.write("\3\u0090\3\u0090\3\u0090\3\u0090\3\u0090\3\u0090\5\u0090")
buf.write("\u074f\n\u0090\3\u0091\3\u0091\3\u0092\3\u0092\3\u0092")
buf.write("\3\u0092\3\u0092\3\u0093\3\u0093\3\u0093\3\u0093\3\u0094")
buf.write("\3\u0094\3\u0095\3\u0095\5\u0095\u0760\n\u0095\3\u0096")
buf.write("\3\u0096\3\u0096\3\u0097\3\u0097\3\u0098\3\u0098\3\u0099")
buf.write("\3\u0099\3\u0099\5\u0099\u076c\n\u0099\3\u0099\3\u0099")
buf.write("\3\u0099\3\u0099\7\u0099\u0772\n\u0099\f\u0099\16\u0099")
buf.write("\u0775\13\u0099\3\u009a\3\u009a\5\u009a\u0779\n\u009a")
buf.write("\3\u009b\3\u009b\3\u009c\3\u009c\5\u009c\u077f\n\u009c")
buf.write("\3\u009d\3\u009d\3\u009d\3\u009d\3\u009e\3\u009e\3\u009f")
buf.write("\3\u009f\5\u009f\u0789\n\u009f\3\u009f\3\u009f\3\u009f")
buf.write("\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\5\u009f\u0793")
buf.write("\n\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f")
buf.write("\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f")
buf.write("\3\u009f\5\u009f\u07a3\n\u009f\3\u00a0\6\u00a0\u07a6\n")
buf.write("\u00a0\r\u00a0\16\u00a0\u07a7\3\u00a1\3\u00a1\5\u00a1")
buf.write("\u07ac\n\u00a1\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a2")
buf.write("\5\u00a2\u07b3\n\u00a2\3\u00a3\3\u00a3\3\u00a3\3\u00a3")
buf.write("\3\u00a3\3\u00a3\5\u00a3\u07bb\n\u00a3\3\u00a4\3\u00a4")
buf.write("\3\u00a4\3\u00a4\3\u00a4\3\u00a4\7\u00a4\u07c3\n\u00a4")
buf.write("\f\u00a4\16\u00a4\u07c6\13\u00a4\3\u00a5\3\u00a5\3\u00a6")
buf.write("\3\u00a6\3\u00a6\5\u00a6\u07cd\n\u00a6\3\u00a7\3\u00a7")
buf.write("\3\u00a7\3\u00a7\3\u00a7\7\u00a7\u07d4\n\u00a7\f\u00a7")
buf.write("\16\u00a7\u07d7\13\u00a7\3\u00a8\3\u00a8\3\u00a8\3\u00a8")
buf.write("\3\u00a8\3\u00a9\3\u00a9\3\u00aa\3\u00aa\3\u00aa\3\u00aa")
buf.write("\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa")
buf.write("\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa")
buf.write("\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa")
buf.write("\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa\5\u00aa\u07fe")
buf.write("\n\u00aa\3\u00ab\3\u00ab\3\u00ab\3\u00ab\5\u00ab\u0804")
buf.write("\n\u00ab\3\u00ac\3\u00ac\5\u00ac\u0808\n\u00ac\3\u00ac")
buf.write("\3\u00ac\3\u00ac\5\u00ac\u080d\n\u00ac\5\u00ac\u080f\n")
buf.write("\u00ac\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ad\7\u00ad")
buf.write("\u0816\n\u00ad\f\u00ad\16\u00ad\u0819\13\u00ad\3\u00ae")
buf.write("\3\u00ae\5\u00ae\u081d\n\u00ae\3\u00af\3\u00af\3\u00af")
buf.write("\3\u00af\3\u00af\3\u00af\5\u00af\u0825\n\u00af\3\u00b0")
buf.write("\3\u00b0\3\u00b0\3\u00b0\3\u00b0\5\u00b0\u082c\n\u00b0")
buf.write("\3\u00b1\6\u00b1\u082f\n\u00b1\r\u00b1\16\u00b1\u0830")
buf.write("\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2")
buf.write("\3\u00b2\3\u00b2\3\u00b2\5\u00b2\u083d\n\u00b2\3\u00b3")
buf.write("\3\u00b3\3\u00b3\7\u00b3\u0842\n\u00b3\f\u00b3\16\u00b3")
buf.write("\u0845\13\u00b3\3\u00b3\5\u00b3\u0848\n\u00b3\3\u00b3")
buf.write("\3\u00b3\3\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b4")
buf.write("\3\u00b5\7\u00b5\u0853\n\u00b5\f\u00b5\16\u00b5\u0856")
buf.write("\13\u00b5\3\u00b6\3\u00b6\3\u00b6\3\u00b7\3\u00b7\3\u00b7")
buf.write("\3\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b7")
buf.write("\3\u00b7\3\u00b7\3\u00b7\5\u00b7\u0868\n\u00b7\3\u00b8")
buf.write("\3\u00b8\3\u00b8\3\u00b9\3\u00b9\3\u00ba\3\u00ba\3\u00ba")
buf.write("\5\u00ba\u0872\n\u00ba\3\u00bb\3\u00bb\5\u00bb\u0876\n")
buf.write("\u00bb\3\u00bc\5\u00bc\u0879\n\u00bc\3\u00bc\3\u00bc\5")
buf.write("\u00bc\u087d\n\u00bc\3\u00bc\7\u00bc\u0880\n\u00bc\f\u00bc")
buf.write("\16\u00bc\u0883\13\u00bc\3\u00bc\3\u00bc\3\u00bd\3\u00bd")
buf.write("\5\u00bd\u0889\n\u00bd\3\u00bd\3\u00bd\3\u00bd\5\u00bd")
buf.write("\u088e\n\u00bd\5\u00bd\u0890\n\u00bd\3\u00be\3\u00be\3")
buf.write("\u00bf\3\u00bf\3\u00bf\3\u00c0\3\u00c0\3\u00c0\3\u00c0")
buf.write("\7\u00c0\u089b\n\u00c0\f\u00c0\16\u00c0\u089e\13\u00c0")
buf.write("\3\u00c0\3\u00c0\3\u00c0\3\u00c1\3\u00c1\3\u00c2\3\u00c2")
buf.write("\3\u00c3\3\u00c3\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4")
buf.write("\5\u00c4\u08ae\n\u00c4\3\u00c5\3\u00c5\3\u00c5\3\u00c5")
buf.write("\3\u00c6\3\u00c6\3\u00c6\5\u00c6\u08b7\n\u00c6\3\u00c6")
buf.write("\7\u00c6\u08ba\n\u00c6\f\u00c6\16\u00c6\u08bd\13\u00c6")
buf.write("\3\u00c7\3\u00c7\3\u00c7\3\u00c8\3\u00c8\3\u00c8\7\u00c8")
buf.write("\u08c5\n\u00c8\f\u00c8\16\u00c8\u08c8\13\u00c8\3\u00c8")
buf.write("\3\u00c8\3\u00c9\3\u00c9\3\u00c9\7\u00c9\u08cf\n\u00c9")
buf.write("\f\u00c9\16\u00c9\u08d2\13\u00c9\3\u00c9\3\u00c9\3\u00ca")
buf.write("\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca")
buf.write("\3\u00ca\5\u00ca\u08df\n\u00ca\3\u00cb\3\u00cb\5\u00cb")
buf.write("\u08e3\n\u00cb\3\u00cc\3\u00cc\5\u00cc\u08e7\n\u00cc\3")
buf.write("\u00cc\5\u00cc\u08ea\n\u00cc\3\u00cd\3\u00cd\3\u00cd\3")
buf.write("\u00cd\3\u00ce\6\u00ce\u08f1\n\u00ce\r\u00ce\16\u00ce")
buf.write("\u08f2\3\u00cf\3\u00cf\3\u00d0\3\u00d0\5\u00d0\u08f9\n")
buf.write("\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d1\3\u00d1\3\u00d1")
buf.write("\3\u00d1\3\u00d1\3\u00d1\3\u00d1\3\u00d1\3\u00d1\3\u00d1")
buf.write("\3\u00d1\3\u00d1\3\u00d1\3\u00d1\3\u00d1\3\u00d1\3\u00d1")
buf.write("\3\u00d1\3\u00d1\3\u00d1\3\u00d1\3\u00d1\5\u00d1\u0914")
buf.write("\n\u00d1\3\u00d2\6\u00d2\u0917\n\u00d2\r\u00d2\16\u00d2")
buf.write("\u0918\3\u00d3\3\u00d3\3\u00d3\5\u00d3\u091e\n\u00d3\3")
buf.write("\u00d4\3\u00d4\3\u00d4\3\u00d4\3\u00d4\3\u00d4\7\u00d4")
buf.write("\u0926\n\u00d4\f\u00d4\16\u00d4\u0929\13\u00d4\3\u00d5")
buf.write("\3\u00d5\3\u00d5\3\u00d5\3\u00d5\3\u00d5\3\u00d5\3\u00d5")
buf.write("\5\u00d5\u0933\n\u00d5\3\u00d6\3\u00d6\3\u00d6\3\u00d6")
buf.write("\3\u00d6\3\u00d6\3\u00d6\3\u00d6\3\u00d6\3\u00d6\5\u00d6")
buf.write("\u093f\n\u00d6\3\u00d7\3\u00d7\3\u00d8\5\u00d8\u0944\n")
buf.write("\u00d8\3\u00d8\3\u00d8\3\u00d9\3\u00d9\3\u00d9\3\u00d9")
buf.write("\3\u00d9\3\u00d9\5\u00d9\u094e\n\u00d9\3\u00d9\3\u00d9")
buf.write("\3\u00d9\3\u00d9\3\u00d9\5\u00d9\u0955\n\u00d9\3\u00da")
buf.write("\3\u00da\3\u00db\3\u00db\3\u00db\3\u00dc\3\u00dc\3\u00dc")
buf.write("\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc")
buf.write("\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc")
buf.write("\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc")
buf.write("\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc\5\u00dc\u0979")
buf.write("\n\u00dc\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00dd")
buf.write("\3\u00de\3\u00de\3\u00de\3\u00de\3\u00de\5\u00de\u0986")
buf.write("\n\u00de\3\u00de\3\u00de\3\u00de\3\u00de\3\u00de\5\u00de")
buf.write("\u098d\n\u00de\3\u00df\3\u00df\3\u00e0\3\u00e0\3\u00e0")
buf.write("\3\u00e0\3\u00e0\3\u00e1\3\u00e1\3\u00e1\7\u00e1\u0999")
buf.write("\n\u00e1\f\u00e1\16\u00e1\u099c\13\u00e1\3\u00e2\3\u00e2")
buf.write("\5\u00e2\u09a0\n\u00e2\3\u00e3\3\u00e3\3\u00e3\5\u00e3")
buf.write("\u09a5\n\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3")
buf.write("\7\u00e3\u09ac\n\u00e3\f\u00e3\16\u00e3\u09af\13\u00e3")
buf.write("\3\u00e4\3\u00e4\5\u00e4\u09b3\n\u00e4\3\u00e5\3\u00e5")
buf.write("\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5")
buf.write("\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\5\u00e5\u09c3")
buf.write("\n\u00e5\3\u00e6\3\u00e6\3\u00e6\7\u00e6\u09c8\n\u00e6")
buf.write("\f\u00e6\16\u00e6\u09cb\13\u00e6\3\u00e7\3\u00e7\5\u00e7")
buf.write("\u09cf\n\u00e7\3\u00e8\3\u00e8\3\u00e8\3\u00e8\3\u00e8")
buf.write("\3\u00e8\3\u00e8\3\u00e8\3\u00e8\3\u00e8\3\u00e8\3\u00e8")
buf.write("\3\u00e8\3\u00e8\5\u00e8\u09df\n\u00e8\3\u00e9\3\u00e9")
buf.write("\3\u00e9\7\u00e9\u09e4\n\u00e9\f\u00e9\16\u00e9\u09e7")
buf.write("\13\u00e9\3\u00ea\3\u00ea\3\u00ea\3\u00ea\5\u00ea\u09ed")
buf.write("\n\u00ea\3\u00eb\3\u00eb\3\u00eb\3\u00eb\3\u00eb\7\u00eb")
buf.write("\u09f4\n\u00eb\f\u00eb\16\u00eb\u09f7\13\u00eb\3\u00ec")
buf.write("\3\u00ec\3\u00ec\3\u00ec\3\u00ed\3\u00ed\5\u00ed\u09ff")
buf.write("\n\u00ed\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\5\u00ee")
buf.write("\u0a06\n\u00ee\3\u00ef\3\u00ef\3\u00ef\3\u00ef\3\u00ef")
buf.write("\3\u00ef\3\u00ef\3\u00ef\3\u00ef\3\u00ef\3\u00ef\3\u00ef")
buf.write("\3\u00ef\3\u00ef\5\u00ef\u0a16\n\u00ef\3\u00ef\3\u00ef")
buf.write("\3\u00ef\7\u00ef\u0a1b\n\u00ef\f\u00ef\16\u00ef\u0a1e")
buf.write("\13\u00ef\3\u00f0\3\u00f0\3\u00f0\3\u00f1\3\u00f1\5\u00f1")
buf.write("\u0a25\n\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f2")
buf.write("\3\u00f2\3\u00f2\7\u00f2\u0a2e\n\u00f2\f\u00f2\16\u00f2")
buf.write("\u0a31\13\u00f2\3\u00f3\3\u00f3\3\u00f4\3\u00f4\5\u00f4")
buf.write("\u0a37\n\u00f4\3\u00f5\3\u00f5\3\u00f5\3\u00f5\3\u00f5")
buf.write("\3\u00f5\3\u00f5\5\u00f5\u0a40\n\u00f5\3\u00f6\3\u00f6")
buf.write("\3\u00f6\5\u00f6\u0a45\n\u00f6\3\u00f6\3\u00f6\3\u00f6")
buf.write("\5\u00f6\u0a4a\n\u00f6\5\u00f6\u0a4c\n\u00f6\3\u00f7\3")
buf.write("\u00f7\3\u00f7\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f8")
buf.write("\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f8")
buf.write("\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f8\5\u00f8\u0a62")
buf.write("\n\u00f8\3\u00f9\3\u00f9\3\u00f9\3\u00f9\3\u00fa\3\u00fa")
buf.write("\3\u00fa\7\u00fa\u0a6b\n\u00fa\f\u00fa\16\u00fa\u0a6e")
buf.write("\13\u00fa\3\u00fb\3\u00fb\5\u00fb\u0a72\n\u00fb\3\u00fc")
buf.write("\3\u00fc\3\u00fc\3\u00fc\3\u00fc\3\u00fc\3\u00fc\3\u00fc")
buf.write("\3\u00fc\5\u00fc\u0a7d\n\u00fc\3\u00fc\3\u00fc\3\u00fd")
buf.write("\3\u00fd\3\u00fd\3\u00fd\3\u00fd\5\u00fd\u0a86\n\u00fd")
buf.write("\3\u00fe\3\u00fe\3\u00fe\3\u00fe\3\u00fe\3\u00fe\3\u00fe")
buf.write("\5\u00fe\u0a8f\n\u00fe\3\u00ff\3\u00ff\3\u00ff\3\u00ff")
buf.write("\3\u00ff\3\u00ff\3\u00ff\3\u00ff\3\u00ff\3\u00ff\5\u00ff")
buf.write("\u0a9b\n\u00ff\3\u00ff\3\u00ff\3\u00ff\7\u00ff\u0aa0\n")
buf.write("\u00ff\f\u00ff\16\u00ff\u0aa3\13\u00ff\3\u0100\3\u0100")
buf.write("\3\u0100\3\u0100\3\u0100\3\u0100\3\u0100\3\u0100\3\u0100")
buf.write("\3\u0100\3\u0100\3\u0100\3\u0100\3\u0100\3\u0100\3\u0100")
buf.write("\3\u0100\3\u0100\3\u0100\3\u0100\3\u0100\3\u0100\3\u0100")
buf.write("\3\u0100\3\u0100\3\u0100\3\u0100\3\u0100\3\u0100\3\u0100")
buf.write("\5\u0100\u0ac3\n\u0100\3\u0101\3\u0101\3\u0101\3\u0101")
buf.write("\3\u0101\3\u0101\3\u0101\5\u0101\u0acc\n\u0101\3\u0102")
buf.write("\3\u0102\5\u0102\u0ad0\n\u0102\3\u0103\3\u0103\3\u0103")
buf.write("\3\u0103\3\u0103\3\u0103\3\u0103\3\u0103\3\u0103\3\u0103")
buf.write("\5\u0103\u0adc\n\u0103\3\u0103\3\u0103\3\u0103\3\u0103")
buf.write("\3\u0103\3\u0103\7\u0103\u0ae4\n\u0103\f\u0103\16\u0103")
buf.write("\u0ae7\13\u0103\3\u0104\3\u0104\3\u0104\3\u0104\3\u0104")
buf.write("\3\u0104\3\u0104\3\u0104\3\u0104\5\u0104\u0af2\n\u0104")
buf.write("\3\u0104\3\u0104\3\u0104\3\u0104\3\u0104\3\u0104\3\u0104")
buf.write("\3\u0104\3\u0104\3\u0104\3\u0104\5\u0104\u0aff\n\u0104")
buf.write("\3\u0104\3\u0104\5\u0104\u0b03\n\u0104\3\u0105\3\u0105")
buf.write("\3\u0105\5\u0105\u0b08\n\u0105\3\u0106\3\u0106\5\u0106")
buf.write("\u0b0c\n\u0106\3\u0107\3\u0107\3\u0107\3\u0107\3\u0107")
buf.write("\3\u0108\5\u0108\u0b14\n\u0108\3\u0108\5\u0108\u0b17\n")
buf.write("\u0108\3\u0108\3\u0108\7\u0108\u0b1b\n\u0108\f\u0108\16")
buf.write("\u0108\u0b1e\13\u0108\3\u0109\3\u0109\3\u0109\3\u0109")
buf.write("\3\u0109\3\u0109\3\u0109\3\u0109\3\u0109\3\u0109\3\u0109")
buf.write("\3\u0109\3\u0109\3\u0109\3\u0109\3\u0109\3\u0109\3\u0109")
buf.write("\3\u0109\3\u0109\3\u0109\3\u0109\3\u0109\3\u0109\3\u0109")
buf.write("\3\u0109\3\u0109\3\u0109\3\u0109\3\u0109\3\u0109\3\u0109")
buf.write("\3\u0109\3\u0109\3\u0109\3\u0109\3\u0109\3\u0109\3\u0109")
buf.write("\5\u0109\u0b47\n\u0109\3\u010a\3\u010a\3\u010a\3\u010a")
buf.write("\3\u010a\3\u010a\3\u010a\3\u010a\3\u010a\3\u010a\3\u010a")
buf.write("\3\u010a\3\u010a\5\u010a\u0b56\n\u010a\3\u010b\5\u010b")
buf.write("\u0b59\n\u010b\3\u010b\5\u010b\u0b5c\n\u010b\3\u010b\3")
buf.write("\u010b\7\u010b\u0b60\n\u010b\f\u010b\16\u010b\u0b63\13")
buf.write("\u010b\3\u010c\3\u010c\3\u010c\3\u010c\3\u010c\3\u010c")
buf.write("\3\u010c\3\u010c\3\u010c\3\u010c\3\u010c\3\u010c\3\u010c")
buf.write("\3\u010c\3\u010c\3\u010c\3\u010c\3\u010c\3\u010c\3\u010c")
buf.write("\3\u010c\3\u010c\3\u010c\3\u010c\3\u010c\3\u010c\3\u010c")
buf.write("\3\u010c\3\u010c\3\u010c\3\u010c\3\u010c\3\u010c\3\u010c")
buf.write("\3\u010c\3\u010c\3\u010c\3\u010c\3\u010c\3\u010c\3\u010c")
buf.write("\3\u010c\3\u010c\3\u010c\3\u010c\3\u010c\3\u010c\3\u010c")
buf.write("\3\u010c\3\u010c\3\u010c\3\u010c\3\u010c\3\u010c\3\u010c")
buf.write("\3\u010c\3\u010c\3\u010c\3\u010c\3\u010c\3\u010c\3\u010c")
buf.write("\3\u010c\3\u010c\3\u010c\3\u010c\3\u010c\3\u010c\3\u010c")
buf.write("\3\u010c\3\u010c\3\u010c\3\u010c\3\u010c\3\u010c\5\u010c")
buf.write("\u0bb0\n\u010c\3\u010d\3\u010d\3\u010d\5\u010d\u0bb5\n")
buf.write("\u010d\3\u010d\3\u010d\3\u010d\3\u010d\5\u010d\u0bbb\n")
buf.write("\u010d\3\u010d\3\u010d\3\u010d\3\u010d\3\u010d\3\u010d")
buf.write("\3\u010d\3\u010d\5\u010d\u0bc5\n\u010d\3\u010d\3\u010d")
buf.write("\3\u010d\3\u010d\3\u010d\5\u010d\u0bcc\n\u010d\3\u010e")
buf.write("\3\u010e\3\u010e\3\u010f\3\u010f\3\u010f\5\u010f\u0bd4")
buf.write("\n\u010f\3\u010f\3\u010f\3\u0110\3\u0110\3\u0110\3\u0110")
buf.write("\3\u0110\5\u0110\u0bdd\n\u0110\3\u0110\3\u0110\3\u0111")
buf.write("\3\u0111\3\u0111\7\u0111\u0be4\n\u0111\f\u0111\16\u0111")
buf.write("\u0be7\13\u0111\3\u0112\3\u0112\3\u0112\5\u0112\u0bec")
buf.write("\n\u0112\3\u0112\3\u0112\3\u0112\3\u0112\5\u0112\u0bf2")
buf.write("\n\u0112\3\u0112\3\u0112\3\u0112\3\u0112\5\u0112\u0bf8")
buf.write("\n\u0112\3\u0113\3\u0113\3\u0114\3\u0114\3\u0114\3\u0114")
buf.write("\3\u0114\3\u0115\5\u0115\u0c02\n\u0115\3\u0115\5\u0115")
buf.write("\u0c05\n\u0115\3\u0115\3\u0115\7\u0115\u0c09\n\u0115\f")
buf.write("\u0115\16\u0115\u0c0c\13\u0115\3\u0116\3\u0116\3\u0116")
buf.write("\3\u0116\3\u0116\3\u0116\3\u0116\3\u0116\3\u0116\3\u0116")
buf.write("\3\u0116\5\u0116\u0c19\n\u0116\3\u0117\3\u0117\7\u0117")
buf.write("\u0c1d\n\u0117\f\u0117\16\u0117\u0c20\13\u0117\3\u0118")
buf.write("\3\u0118\3\u0118\3\u0118\3\u0118\5\u0118\u0c27\n\u0118")
buf.write("\3\u0119\3\u0119\3\u0119\5\u0119\u0c2c\n\u0119\3\u011a")
buf.write("\3\u011a\3\u011a\3\u011a\3\u011a\3\u011a\3\u011b\3\u011b")
buf.write("\3\u011b\3\u011b\3\u011b\3\u011b\3\u011b\3\u011b\5\u011b")
buf.write("\u0c3c\n\u011b\3\u011c\3\u011c\3\u011d\5\u011d\u0c41\n")
buf.write("\u011d\3\u011d\3\u011d\7\u011d\u0c45\n\u011d\f\u011d\16")
buf.write("\u011d\u0c48\13\u011d\3\u011e\3\u011e\3\u011e\3\u011e")
buf.write("\3\u011e\3\u011e\3\u011e\3\u011e\3\u011e\3\u011e\3\u011e")
buf.write("\3\u011e\3\u011e\3\u011e\5\u011e\u0c58\n\u011e\3\u011f")
buf.write("\3\u011f\3\u011f\3\u011f\3\u011f\3\u011f\3\u011f\3\u011f")
buf.write("\3\u011f\3\u011f\3\u0120\3\u0120\3\u0121\3\u0121\3\u0122")
buf.write("\5\u0122\u0c69\n\u0122\3\u0122\3\u0122\5\u0122\u0c6d\n")
buf.write("\u0122\3\u0122\5\u0122\u0c70\n\u0122\3\u0122\3\u0122\3")
buf.write("\u0122\3\u0122\5\u0122\u0c76\n\u0122\3\u0122\3\u0122\3")
buf.write("\u0122\3\u0122\3\u0122\3\u0122\3\u0122\3\u0122\3\u0122")
buf.write("\3\u0122\3\u0122\3\u0122\3\u0122\3\u0122\5\u0122\u0c86")
buf.write("\n\u0122\3\u0123\3\u0123\3\u0123\7\u0123\u0c8b\n\u0123")
buf.write("\f\u0123\16\u0123\u0c8e\13\u0123\3\u0123\3\u0123\3\u0124")
buf.write("\3\u0124\5\u0124\u0c94\n\u0124\3\u0124\5\u0124\u0c97\n")
buf.write("\u0124\3\u0124\3\u0124\5\u0124\u0c9b\n\u0124\3\u0124\5")
buf.write("\u0124\u0c9e\n\u0124\3\u0124\3\u0124\3\u0124\3\u0124\3")
buf.write("\u0124\3\u0124\5\u0124\u0ca6\n\u0124\3\u0124\3\u0124\5")
buf.write("\u0124\u0caa\n\u0124\3\u0125\3\u0125\3\u0125\3\u0126\3")
buf.write("\u0126\3\u0126\3\u0126\3\u0126\3\u0127\3\u0127\3\u0127")
buf.write("\3\u0127\3\u0127\3\u0127\3\u0127\5\u0127\u0cbb\n\u0127")
buf.write("\3\u0128\3\u0128\5\u0128\u0cbf\n\u0128\3\u0129\5\u0129")
buf.write("\u0cc2\n\u0129\3\u0129\6\u0129\u0cc5\n\u0129\r\u0129\16")
buf.write("\u0129\u0cc6\3\u012a\3\u012a\5\u012a\u0ccb\n\u012a\3\u012b")
buf.write("\3\u012b\3\u012b\3\u012b\3\u012b\3\u012b\3\u012b\3\u012b")
buf.write("\3\u012b\5\u012b\u0cd6\n\u012b\3\u012c\3\u012c\5\u012c")
buf.write("\u0cda\n\u012c\3\u012d\3\u012d\3\u012d\3\u012d\5\u012d")
buf.write("\u0ce0\n\u012d\3\u012d\3\u012d\3\u012d\7\u012d\u0ce5\n")
buf.write("\u012d\f\u012d\16\u012d\u0ce8\13\u012d\3\u012e\3\u012e")
buf.write("\3\u012e\3\u012e\3\u012e\3\u012e\3\u012e\3\u012e\3\u012e")
buf.write("\3\u012e\3\u012e\7\u012e\u0cf5\n\u012e\f\u012e\16\u012e")
buf.write("\u0cf8\13\u012e\3\u012f\3\u012f\3\u012f\3\u012f\3\u012f")
buf.write("\5\u012f\u0cff\n\u012f\3\u0130\3\u0130\3\u0130\3\u0130")
buf.write("\3\u0130\3\u0130\3\u0130\3\u0130\5\u0130\u0d09\n\u0130")
buf.write("\3\u0131\3\u0131\3\u0131\3\u0131\3\u0131\3\u0131\3\u0131")
buf.write("\3\u0131\3\u0131\5\u0131\u0d14\n\u0131\3\u0132\3\u0132")
buf.write("\3\u0133\3\u0133\5\u0133\u0d1a\n\u0133\3\u0133\3\u0133")
buf.write("\3\u0133\3\u0133\3\u0133\3\u0133\5\u0133\u0d22\n\u0133")
buf.write("\3\u0134\3\u0134\3\u0134\3\u0135\3\u0135\3\u0135\3\u0135")
buf.write("\5\u0135\u0d2b\n\u0135\3\u0136\3\u0136\3\u0136\7\u0136")
buf.write("\u0d30\n\u0136\f\u0136\16\u0136\u0d33\13\u0136\3\u0137")
buf.write("\3\u0137\3\u0137\3\u0137\3\u0137\3\u0137\3\u0137\3\u0137")
buf.write("\5\u0137\u0d3d\n\u0137\3\u0138\5\u0138\u0d40\n\u0138\3")
buf.write("\u0138\3\u0138\7\u0138\u0d44\n\u0138\f\u0138\16\u0138")
buf.write("\u0d47\13\u0138\3\u0139\3\u0139\3\u0139\3\u0139\3\u013a")
buf.write("\3\u013a\3\u013a\3\u013a\3\u013a\3\u013a\3\u013a\7\u013a")
buf.write("\u0d54\n\u013a\f\u013a\16\u013a\u0d57\13\u013a\3\u013b")
buf.write("\3\u013b\3\u013c\3\u013c\3\u013c\7\u013c\u0d5e\n\u013c")
buf.write("\f\u013c\16\u013c\u0d61\13\u013c\3\u013d\3\u013d\3\u013d")
buf.write("\7\u013d\u0d66\n\u013d\f\u013d\16\u013d\u0d69\13\u013d")
buf.write("\3\u013e\3\u013e\3\u013e\7\u013e\u0d6e\n\u013e\f\u013e")
buf.write("\16\u013e\u0d71\13\u013e\3\u013f\5\u013f\u0d74\n\u013f")
buf.write("\3\u013f\3\u013f\3\u0140\3\u0140\3\u0141\3\u0141\3\u0141")
buf.write("\3\u0141\7\u0141\u0d7e\n\u0141\f\u0141\16\u0141\u0d81")
buf.write("\13\u0141\3\u0142\3\u0142\3\u0142\5\u0142\u0d86\n\u0142")
buf.write("\3\u0142\3\u0142\5\u0142\u0d8a\n\u0142\3\u0142\7\u0142")
buf.write("\u0d8d\n\u0142\f\u0142\16\u0142\u0d90\13\u0142\3\u0143")
buf.write("\5\u0143\u0d93\n\u0143\3\u0143\3\u0143\3\u0143\7\u0143")
buf.write("\u0d98\n\u0143\f\u0143\16\u0143\u0d9b\13\u0143\3\u0144")
buf.write("\3\u0144\3\u0145\3\u0145\3\u0145\7\u0145\u0da2\n\u0145")
buf.write("\f\u0145\16\u0145\u0da5\13\u0145\3\u0146\3\u0146\3\u0146")
buf.write("\7\u0146\u0daa\n\u0146\f\u0146\16\u0146\u0dad\13\u0146")
buf.write("\3\u0147\3\u0147\3\u0147\3\u0147\5\u0147\u0db3\n\u0147")
buf.write("\3\u0148\3\u0148\3\u0149\3\u0149\3\u0149\3\u0149\3\u0149")
buf.write("\3\u0149\3\u0149\3\u0149\3\u0149\3\u0149\5\u0149\u0dc1")
buf.write("\n\u0149\3\u014a\3\u014a\3\u014a\3\u014a\3\u014b\3\u014b")
buf.write("\5\u014b\u0dc9\n\u014b\3\u014c\3\u014c\3\u014c\3\u014c")
buf.write("\3\u014c\3\u014c\3\u014c\3\u014c\3\u014c\3\u014c\5\u014c")
buf.write("\u0dd5\n\u014c\3\u014c\3\u014c\3\u014c\3\u014c\3\u014c")
buf.write("\3\u014c\7\u014c\u0ddd\n\u014c\f\u014c\16\u014c\u0de0")
buf.write("\13\u014c\3\u014d\3\u014d\3\u014d\3\u014d\3\u014d\3\u014d")
buf.write("\3\u014d\3\u014d\3\u014d\3\u014d\3\u014d\3\u014d\3\u014d")
buf.write("\3\u014d\3\u014d\3\u014d\3\u014d\3\u014d\3\u014d\3\u014d")
buf.write("\3\u014d\3\u014d\3\u014d\3\u014d\3\u014d\3\u014d\3\u014d")
buf.write("\3\u014d\3\u014d\3\u014d\3\u014d\3\u014d\3\u014d\3\u014d")
buf.write("\3\u014d\3\u014d\3\u014d\3\u014d\3\u014d\3\u014d\3\u014d")
buf.write("\3\u014d\3\u014d\3\u014d\5\u014d\u0e0e\n\u014d\3\u014e")
buf.write("\3\u014e\3\u014e\3\u014e\3\u014e\3\u014e\3\u014e\3\u014e")
buf.write("\5\u014e\u0e18\n\u014e\3\u014f\3\u014f\3\u014f\3\u014f")
buf.write("\3\u014f\3\u014f\5\u014f\u0e20\n\u014f\3\u014f\3\u014f")
buf.write("\3\u014f\7\u014f\u0e25\n\u014f\f\u014f\16\u014f\u0e28")
buf.write("\13\u014f\3\u0150\3\u0150\3\u0150\3\u0150\3\u0151\3\u0151")
buf.write("\7\u0151\u0e30\n\u0151\f\u0151\16\u0151\u0e33\13\u0151")
buf.write("\3\u0152\3\u0152\3\u0152\5\u0152\u0e38\n\u0152\3\u0153")
buf.write("\3\u0153\3\u0153\3\u0153\3\u0154\3\u0154\3\u0154\7\u0154")
buf.write("\u0e41\n\u0154\f\u0154\16\u0154\u0e44\13\u0154\3\u0155")
buf.write("\3\u0155\5\u0155\u0e48\n\u0155\3\u0155\5\u0155\u0e4b\n")
buf.write("\u0155\3\u0156\3\u0156\5\u0156\u0e4f\n\u0156\3\u0156\3")
buf.write("\u0156\3\u0156\3\u0156\3\u0156\3\u0156\3\u0156\5\u0156")
buf.write("\u0e58\n\u0156\3\u0157\3\u0157\3\u0157\3\u0157\3\u0157")
buf.write("\3\u0157\3\u0157\3\u0157\3\u0157\5\u0157\u0e63\n\u0157")
buf.write("\3\u0158\3\u0158\5\u0158\u0e67\n\u0158\3\u0159\3\u0159")
buf.write("\3\u0159\3\u0159\3\u0159\3\u0159\3\u0159\3\u0159\5\u0159")
buf.write("\u0e71\n\u0159\3\u015a\3\u015a\3\u015a\3\u015a\3\u015a")
buf.write("\3\u015b\5\u015b\u0e79\n\u015b\3\u015b\3\u015b\3\u015b")
buf.write("\5\u015b\u0e7e\n\u015b\3\u015c\3\u015c\3\u015d\3\u015d")
buf.write("\3\u015d\3\u015d\3\u015d\3\u015d\3\u015d\2\33\16,\64`")
buf.write("\u00a4\u00b0\u00bc\u00cc\u00e8\u00f2\u0130\u0146\u014c")
buf.write("\u0158\u01a6\u01c4\u01d4\u01dc\u01fc\u0204\u0258\u025a")
buf.write("\u0272\u0296\u029c\u015e\2\4\6\b\n\f\16\20\22\24\26\30")
buf.write("\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`b")
buf.write("dfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c")
buf.write("\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e")
buf.write("\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0")
buf.write("\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc\u00be\u00c0\u00c2")
buf.write("\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4")
buf.write("\u00d6\u00d8\u00da\u00dc\u00de\u00e0\u00e2\u00e4\u00e6")
buf.write("\u00e8\u00ea\u00ec\u00ee\u00f0\u00f2\u00f4\u00f6\u00f8")
buf.write("\u00fa\u00fc\u00fe\u0100\u0102\u0104\u0106\u0108\u010a")
buf.write("\u010c\u010e\u0110\u0112\u0114\u0116\u0118\u011a\u011c")
buf.write("\u011e\u0120\u0122\u0124\u0126\u0128\u012a\u012c\u012e")
buf.write("\u0130\u0132\u0134\u0136\u0138\u013a\u013c\u013e\u0140")
buf.write("\u0142\u0144\u0146\u0148\u014a\u014c\u014e\u0150\u0152")
buf.write("\u0154\u0156\u0158\u015a\u015c\u015e\u0160\u0162\u0164")
buf.write("\u0166\u0168\u016a\u016c\u016e\u0170\u0172\u0174\u0176")
buf.write("\u0178\u017a\u017c\u017e\u0180\u0182\u0184\u0186\u0188")
buf.write("\u018a\u018c\u018e\u0190\u0192\u0194\u0196\u0198\u019a")
buf.write("\u019c\u019e\u01a0\u01a2\u01a4\u01a6\u01a8\u01aa\u01ac")
buf.write("\u01ae\u01b0\u01b2\u01b4\u01b6\u01b8\u01ba\u01bc\u01be")
buf.write("\u01c0\u01c2\u01c4\u01c6\u01c8\u01ca\u01cc\u01ce\u01d0")
buf.write("\u01d2\u01d4\u01d6\u01d8\u01da\u01dc\u01de\u01e0\u01e2")
buf.write("\u01e4\u01e6\u01e8\u01ea\u01ec\u01ee\u01f0\u01f2\u01f4")
buf.write("\u01f6\u01f8\u01fa\u01fc\u01fe\u0200\u0202\u0204\u0206")
buf.write("\u0208\u020a\u020c\u020e\u0210\u0212\u0214\u0216\u0218")
buf.write("\u021a\u021c\u021e\u0220\u0222\u0224\u0226\u0228\u022a")
buf.write("\u022c\u022e\u0230\u0232\u0234\u0236\u0238\u023a\u023c")
buf.write("\u023e\u0240\u0242\u0244\u0246\u0248\u024a\u024c\u024e")
buf.write("\u0250\u0252\u0254\u0256\u0258\u025a\u025c\u025e\u0260")
buf.write("\u0262\u0264\u0266\u0268\u026a\u026c\u026e\u0270\u0272")
buf.write("\u0274\u0276\u0278\u027a\u027c\u027e\u0280\u0282\u0284")
buf.write("\u0286\u0288\u028a\u028c\u028e\u0290\u0292\u0294\u0296")
buf.write("\u0298\u029a\u029c\u029e\u02a0\u02a2\u02a4\u02a6\u02a8")
buf.write("\u02aa\u02ac\u02ae\u02b0\u02b2\u02b4\u02b6\u02b8\2\16")
buf.write("\3\2\25\27\3\2\u0085\u0086\3\2\u0091\u0096\3\2\u008d\u008e")
buf.write("\3\2()\3\2\u00b0\u00b2\4\2\u00b3\u00b3\u00bc\u00bc\4\2")
buf.write("\u0087\u0087\u00c2\u00c2\4\2\36\36\u0091\u0096\5\2$$V")
buf.write("V\u00be\u00be\3\2\u0097\u0098\4\2\u00b4\u00b4\u00bc\u00bc")
buf.write("\2\u0f54\2\u02ba\3\2\2\2\4\u02bd\3\2\2\2\6\u02c6\3\2\2")
buf.write("\2\b\u02c9\3\2\2\2\n\u02cd\3\2\2\2\f\u02d7\3\2\2\2\16")
buf.write("\u02e1\3\2\2\2\20\u02ec\3\2\2\2\22\u02f5\3\2\2\2\24\u0308")
buf.write("\3\2\2\2\26\u030a\3\2\2\2\30\u0318\3\2\2\2\32\u031a\3")
buf.write("\2\2\2\34\u0322\3\2\2\2\36\u0326\3\2\2\2 \u0328\3\2\2")
buf.write("\2\"\u032e\3\2\2\2$\u0332\3\2\2\2&\u033c\3\2\2\2(\u0345")
buf.write("\3\2\2\2*\u0350\3\2\2\2,\u0352\3\2\2\2.\u035c\3\2\2\2")
buf.write("\60\u0373\3\2\2\2\62\u0375\3\2\2\2\64\u0382\3\2\2\2\66")
buf.write("\u03a2\3\2\2\28\u03ad\3\2\2\2:\u03b7\3\2\2\2<\u03c0\3")
buf.write("\2\2\2>\u03cc\3\2\2\2@\u03ce\3\2\2\2B\u03db\3\2\2\2D\u03dd")
buf.write("\3\2\2\2F\u03e7\3\2\2\2H\u03ed\3\2\2\2J\u03fd\3\2\2\2")
buf.write("L\u03ff\3\2\2\2N\u0405\3\2\2\2P\u0413\3\2\2\2R\u0415\3")
buf.write("\2\2\2T\u041b\3\2\2\2V\u0429\3\2\2\2X\u042b\3\2\2\2Z\u0431")
buf.write("\3\2\2\2\\\u0439\3\2\2\2^\u043b\3\2\2\2`\u043e\3\2\2\2")
buf.write("b\u0459\3\2\2\2d\u045b\3\2\2\2f\u045d\3\2\2\2h\u0466\3")
buf.write("\2\2\2j\u046a\3\2\2\2l\u046c\3\2\2\2n\u046e\3\2\2\2p\u0470")
buf.write("\3\2\2\2r\u0476\3\2\2\2t\u0484\3\2\2\2v\u0486\3\2\2\2")
buf.write("x\u048e\3\2\2\2z\u0490\3\2\2\2|\u049a\3\2\2\2~\u049c\3")
buf.write("\2\2\2\u0080\u04a4\3\2\2\2\u0082\u04a7\3\2\2\2\u0084\u04ad")
buf.write("\3\2\2\2\u0086\u04af\3\2\2\2\u0088\u04b3\3\2\2\2\u008a")
buf.write("\u04b7\3\2\2\2\u008c\u04bb\3\2\2\2\u008e\u04bd\3\2\2\2")
buf.write("\u0090\u04c1\3\2\2\2\u0092\u04c5\3\2\2\2\u0094\u04c7\3")
buf.write("\2\2\2\u0096\u04cb\3\2\2\2\u0098\u04cf\3\2\2\2\u009a\u04d5")
buf.write("\3\2\2\2\u009c\u04d8\3\2\2\2\u009e\u04e1\3\2\2\2\u00a0")
buf.write("\u04e4\3\2\2\2\u00a2\u04e8\3\2\2\2\u00a4\u04eb\3\2\2\2")
buf.write("\u00a6\u0502\3\2\2\2\u00a8\u0504\3\2\2\2\u00aa\u0511\3")
buf.write("\2\2\2\u00ac\u0513\3\2\2\2\u00ae\u051f\3\2\2\2\u00b0\u0521")
buf.write("\3\2\2\2\u00b2\u0540\3\2\2\2\u00b4\u0542\3\2\2\2\u00b6")
buf.write("\u0575\3\2\2\2\u00b8\u0577\3\2\2\2\u00ba\u057d\3\2\2\2")
buf.write("\u00bc\u0588\3\2\2\2\u00be\u0596\3\2\2\2\u00c0\u05a7\3")
buf.write("\2\2\2\u00c2\u05a9\3\2\2\2\u00c4\u05b0\3\2\2\2\u00c6\u05ba")
buf.write("\3\2\2\2\u00c8\u05c5\3\2\2\2\u00ca\u05d4\3\2\2\2\u00cc")
buf.write("\u05d6\3\2\2\2\u00ce\u05e2\3\2\2\2\u00d0\u05e4\3\2\2\2")
buf.write("\u00d2\u05e8\3\2\2\2\u00d4\u05f0\3\2\2\2\u00d6\u05f9\3")
buf.write("\2\2\2\u00d8\u05fb\3\2\2\2\u00da\u0607\3\2\2\2\u00dc\u0609")
buf.write("\3\2\2\2\u00de\u0616\3\2\2\2\u00e0\u0618\3\2\2\2\u00e2")
buf.write("\u061e\3\2\2\2\u00e4\u0624\3\2\2\2\u00e6\u062c\3\2\2\2")
buf.write("\u00e8\u062e\3\2\2\2\u00ea\u063e\3\2\2\2\u00ec\u0640\3")
buf.write("\2\2\2\u00ee\u064c\3\2\2\2\u00f0\u0658\3\2\2\2\u00f2\u065a")
buf.write("\3\2\2\2\u00f4\u0666\3\2\2\2\u00f6\u0668\3\2\2\2\u00f8")
buf.write("\u0677\3\2\2\2\u00fa\u0679\3\2\2\2\u00fc\u06ac\3\2\2\2")
buf.write("\u00fe\u06ae\3\2\2\2\u0100\u06b0\3\2\2\2\u0102\u06be\3")
buf.write("\2\2\2\u0104\u06c2\3\2\2\2\u0106\u06c4\3\2\2\2\u0108\u06d1")
buf.write("\3\2\2\2\u010a\u06d3\3\2\2\2\u010c\u06d5\3\2\2\2\u010e")
buf.write("\u06d7\3\2\2\2\u0110\u06df\3\2\2\2\u0112\u06fa\3\2\2\2")
buf.write("\u0114\u0706\3\2\2\2\u0116\u0708\3\2\2\2\u0118\u072c\3")
buf.write("\2\2\2\u011a\u0734\3\2\2\2\u011c\u073b\3\2\2\2\u011e\u074e")
buf.write("\3\2\2\2\u0120\u0750\3\2\2\2\u0122\u0752\3\2\2\2\u0124")
buf.write("\u0757\3\2\2\2\u0126\u075b\3\2\2\2\u0128\u075f\3\2\2\2")
buf.write("\u012a\u0761\3\2\2\2\u012c\u0764\3\2\2\2\u012e\u0766\3")
buf.write("\2\2\2\u0130\u076b\3\2\2\2\u0132\u0778\3\2\2\2\u0134\u077a")
buf.write("\3\2\2\2\u0136\u077e\3\2\2\2\u0138\u0780\3\2\2\2\u013a")
buf.write("\u0784\3\2\2\2\u013c\u07a2\3\2\2\2\u013e\u07a5\3\2\2\2")
buf.write("\u0140\u07ab\3\2\2\2\u0142\u07b2\3\2\2\2\u0144\u07ba\3")
buf.write("\2\2\2\u0146\u07bc\3\2\2\2\u0148\u07c7\3\2\2\2\u014a\u07cc")
buf.write("\3\2\2\2\u014c\u07ce\3\2\2\2\u014e\u07d8\3\2\2\2\u0150")
buf.write("\u07dd\3\2\2\2\u0152\u07fd\3\2\2\2\u0154\u0803\3\2\2\2")
buf.write("\u0156\u080e\3\2\2\2\u0158\u0810\3\2\2\2\u015a\u081c\3")
buf.write("\2\2\2\u015c\u0824\3\2\2\2\u015e\u082b\3\2\2\2\u0160\u082e")
buf.write("\3\2\2\2\u0162\u083c\3\2\2\2\u0164\u083e\3\2\2\2\u0166")
buf.write("\u084b\3\2\2\2\u0168\u0854\3\2\2\2\u016a\u0857\3\2\2\2")
buf.write("\u016c\u0867\3\2\2\2\u016e\u0869\3\2\2\2\u0170\u086c\3")
buf.write("\2\2\2\u0172\u0871\3\2\2\2\u0174\u0875\3\2\2\2\u0176\u0878")
buf.write("\3\2\2\2\u0178\u088f\3\2\2\2\u017a\u0891\3\2\2\2\u017c")
buf.write("\u0893\3\2\2\2\u017e\u0896\3\2\2\2\u0180\u08a2\3\2\2\2")
buf.write("\u0182\u08a4\3\2\2\2\u0184\u08a6\3\2\2\2\u0186\u08ad\3")
buf.write("\2\2\2\u0188\u08af\3\2\2\2\u018a\u08b3\3\2\2\2\u018c\u08be")
buf.write("\3\2\2\2\u018e\u08c1\3\2\2\2\u0190\u08cb\3\2\2\2\u0192")
buf.write("\u08de\3\2\2\2\u0194\u08e2\3\2\2\2\u0196\u08e4\3\2\2\2")
buf.write("\u0198\u08eb\3\2\2\2\u019a\u08f0\3\2\2\2\u019c\u08f4\3")
buf.write("\2\2\2\u019e\u08f6\3\2\2\2\u01a0\u0913\3\2\2\2\u01a2\u0916")
buf.write("\3\2\2\2\u01a4\u091d\3\2\2\2\u01a6\u091f\3\2\2\2\u01a8")
buf.write("\u0932\3\2\2\2\u01aa\u093e\3\2\2\2\u01ac\u0940\3\2\2\2")
buf.write("\u01ae\u0943\3\2\2\2\u01b0\u0954\3\2\2\2\u01b2\u0956\3")
buf.write("\2\2\2\u01b4\u0958\3\2\2\2\u01b6\u0978\3\2\2\2\u01b8\u097a")
buf.write("\3\2\2\2\u01ba\u098c\3\2\2\2\u01bc\u098e\3\2\2\2\u01be")
buf.write("\u0990\3\2\2\2\u01c0\u0995\3\2\2\2\u01c2\u099f\3\2\2\2")
buf.write("\u01c4\u09a1\3\2\2\2\u01c6\u09b0\3\2\2\2\u01c8\u09c2\3")
buf.write("\2\2\2\u01ca\u09c4\3\2\2\2\u01cc\u09cc\3\2\2\2\u01ce\u09de")
buf.write("\3\2\2\2\u01d0\u09e0\3\2\2\2\u01d2\u09ec\3\2\2\2\u01d4")
buf.write("\u09ee\3\2\2\2\u01d6\u09f8\3\2\2\2\u01d8\u09fc\3\2\2\2")
buf.write("\u01da\u0a00\3\2\2\2\u01dc\u0a15\3\2\2\2\u01de\u0a1f\3")
buf.write("\2\2\2\u01e0\u0a22\3\2\2\2\u01e2\u0a2a\3\2\2\2\u01e4\u0a32")
buf.write("\3\2\2\2\u01e6\u0a34\3\2\2\2\u01e8\u0a3f\3\2\2\2\u01ea")
buf.write("\u0a4b\3\2\2\2\u01ec\u0a4d\3\2\2\2\u01ee\u0a61\3\2\2\2")
buf.write("\u01f0\u0a63\3\2\2\2\u01f2\u0a67\3\2\2\2\u01f4\u0a71\3")
buf.write("\2\2\2\u01f6\u0a73\3\2\2\2\u01f8\u0a85\3\2\2\2\u01fa\u0a8e")
buf.write("\3\2\2\2\u01fc\u0a9a\3\2\2\2\u01fe\u0ac2\3\2\2\2\u0200")
buf.write("\u0acb\3\2\2\2\u0202\u0acf\3\2\2\2\u0204\u0adb\3\2\2\2")
buf.write("\u0206\u0b02\3\2\2\2\u0208\u0b07\3\2\2\2\u020a\u0b09\3")
buf.write("\2\2\2\u020c\u0b0d\3\2\2\2\u020e\u0b13\3\2\2\2\u0210\u0b46")
buf.write("\3\2\2\2\u0212\u0b55\3\2\2\2\u0214\u0b58\3\2\2\2\u0216")
buf.write("\u0baf\3\2\2\2\u0218\u0bcb\3\2\2\2\u021a\u0bcd\3\2\2\2")
buf.write("\u021c\u0bd3\3\2\2\2\u021e\u0bd7\3\2\2\2\u0220\u0be0\3")
buf.write("\2\2\2\u0222\u0bf7\3\2\2\2\u0224\u0bf9\3\2\2\2\u0226\u0bfb")
buf.write("\3\2\2\2\u0228\u0c01\3\2\2\2\u022a\u0c18\3\2\2\2\u022c")
buf.write("\u0c1a\3\2\2\2\u022e\u0c26\3\2\2\2\u0230\u0c2b\3\2\2\2")
buf.write("\u0232\u0c2d\3\2\2\2\u0234\u0c3b\3\2\2\2\u0236\u0c3d\3")
buf.write("\2\2\2\u0238\u0c40\3\2\2\2\u023a\u0c57\3\2\2\2\u023c\u0c59")
buf.write("\3\2\2\2\u023e\u0c63\3\2\2\2\u0240\u0c65\3\2\2\2\u0242")
buf.write("\u0c85\3\2\2\2\u0244\u0c87\3\2\2\2\u0246\u0ca9\3\2\2\2")
buf.write("\u0248\u0cab\3\2\2\2\u024a\u0cae\3\2\2\2\u024c\u0cba\3")
buf.write("\2\2\2\u024e\u0cbe\3\2\2\2\u0250\u0cc1\3\2\2\2\u0252\u0cc8")
buf.write("\3\2\2\2\u0254\u0cd5\3\2\2\2\u0256\u0cd9\3\2\2\2\u0258")
buf.write("\u0cdf\3\2\2\2\u025a\u0ce9\3\2\2\2\u025c\u0cfe\3\2\2\2")
buf.write("\u025e\u0d08\3\2\2\2\u0260\u0d13\3\2\2\2\u0262\u0d15\3")
buf.write("\2\2\2\u0264\u0d21\3\2\2\2\u0266\u0d23\3\2\2\2\u0268\u0d2a")
buf.write("\3\2\2\2\u026a\u0d2c\3\2\2\2\u026c\u0d3c\3\2\2\2\u026e")
buf.write("\u0d3f\3\2\2\2\u0270\u0d48\3\2\2\2\u0272\u0d4c\3\2\2\2")
buf.write("\u0274\u0d58\3\2\2\2\u0276\u0d5a\3\2\2\2\u0278\u0d62\3")
buf.write("\2\2\2\u027a\u0d6a\3\2\2\2\u027c\u0d73\3\2\2\2\u027e\u0d77")
buf.write("\3\2\2\2\u0280\u0d79\3\2\2\2\u0282\u0d82\3\2\2\2\u0284")
buf.write("\u0d92\3\2\2\2\u0286\u0d9c\3\2\2\2\u0288\u0d9e\3\2\2\2")
buf.write("\u028a\u0da6\3\2\2\2\u028c\u0db2\3\2\2\2\u028e\u0db4\3")
buf.write("\2\2\2\u0290\u0dc0\3\2\2\2\u0292\u0dc2\3\2\2\2\u0294\u0dc8")
buf.write("\3\2\2\2\u0296\u0dd4\3\2\2\2\u0298\u0e0d\3\2\2\2\u029a")
buf.write("\u0e17\3\2\2\2\u029c\u0e1f\3\2\2\2\u029e\u0e29\3\2\2\2")
buf.write("\u02a0\u0e2d\3\2\2\2\u02a2\u0e37\3\2\2\2\u02a4\u0e39\3")
buf.write("\2\2\2\u02a6\u0e3d\3\2\2\2\u02a8\u0e4a\3\2\2\2\u02aa\u0e57")
buf.write("\3\2\2\2\u02ac\u0e62\3\2\2\2\u02ae\u0e66\3\2\2\2\u02b0")
buf.write("\u0e70\3\2\2\2\u02b2\u0e72\3\2\2\2\u02b4\u0e7d\3\2\2\2")
buf.write("\u02b6\u0e7f\3\2\2\2\u02b8\u0e81\3\2\2\2\u02ba\u02bb\5")
buf.write("\4\3\2\u02bb\3\3\2\2\2\u02bc\u02be\5\6\4\2\u02bd\u02bc")
buf.write("\3\2\2\2\u02be\u02bf\3\2\2\2\u02bf\u02bd\3\2\2\2\u02bf")
buf.write("\u02c0\3\2\2\2\u02c0\5\3\2\2\2\u02c1\u02c7\5\b\5\2\u02c2")
buf.write("\u02c7\5\u0138\u009d\2\u02c3\u02c7\5\u0260\u0131\2\u02c4")
buf.write("\u02c7\5(\25\2\u02c5\u02c7\5<\37\2\u02c6\u02c1\3\2\2\2")
buf.write("\u02c6\u02c2\3\2\2\2\u02c6\u02c3\3\2\2\2\u02c6\u02c4\3")
buf.write("\2\2\2\u02c6\u02c5\3\2\2\2\u02c7\7\3\2\2\2\u02c8\u02ca")
buf.write("\5\n\6\2\u02c9\u02c8\3\2\2\2\u02c9\u02ca\3\2\2\2\u02ca")
buf.write("\u02cb\3\2\2\2\u02cb\u02cc\5\f\7\2\u02cc\t\3\2\2\2\u02cd")
buf.write("\u02ce\7\7\2\2\u02ce\u02cf\7\u00be\2\2\u02cf\13\3\2\2")
buf.write("\2\u02d0\u02d2\5\u013e\u00a0\2\u02d1\u02d0\3\2\2\2\u02d1")
buf.write("\u02d2\3\2\2\2\u02d2\u02d3\3\2\2\2\u02d3\u02d8\5&\24\2")
buf.write("\u02d4\u02d5\5\16\b\2\u02d5\u02d6\5&\24\2\u02d6\u02d8")
buf.write("\3\2\2\2\u02d7\u02d1\3\2\2\2\u02d7\u02d4\3\2\2\2\u02d8")
buf.write("\r\3\2\2\2\u02d9\u02da\b\b\1\2\u02da\u02db\5\u013e\u00a0")
buf.write("\2\u02db\u02dc\5\u0134\u009b\2\u02dc\u02dd\5\20\t\2\u02dd")
buf.write("\u02e2\3\2\2\2\u02de\u02df\5\u0134\u009b\2\u02df\u02e0")
buf.write("\5\20\t\2\u02e0\u02e2\3\2\2\2\u02e1\u02d9\3\2\2\2\u02e1")
buf.write("\u02de\3\2\2\2\u02e2\u02e7\3\2\2\2\u02e3\u02e4\f\3\2\2")
buf.write("\u02e4\u02e6\5\20\t\2\u02e5\u02e3\3\2\2\2\u02e6\u02e9")
buf.write("\3\2\2\2\u02e7\u02e5\3\2\2\2\u02e7\u02e8\3\2\2\2\u02e8")
buf.write("\17\3\2\2\2\u02e9\u02e7\3\2\2\2\u02ea\u02ed\5\u0138\u009d")
buf.write("\2\u02eb\u02ed\5\u0260\u0131\2\u02ec\u02ea\3\2\2\2\u02ec")
buf.write("\u02eb\3\2\2\2\u02ed\21\3\2\2\2\u02ee\u02f6\5\u0268\u0135")
buf.write("\2\u02ef\u02f6\5 \21\2\u02f0\u02f6\5\62\32\2\u02f1\u02f6")
buf.write("\5@!\2\u02f2\u02f6\5H%\2\u02f3\u02f6\5\u0266\u0134\2\u02f4")
buf.write("\u02f6\5\24\13\2\u02f5\u02ee\3\2\2\2\u02f5\u02ef\3\2\2")
buf.write("\2\u02f5\u02f0\3\2\2\2\u02f5\u02f1\3\2\2\2\u02f5\u02f2")
buf.write("\3\2\2\2\u02f5\u02f3\3\2\2\2\u02f5\u02f4\3\2\2\2\u02f6")
buf.write("\23\3\2\2\2\u02f7\u02f8\7\31\2\2\u02f8\u0309\7\u00be\2")
buf.write("\2\u02f9\u02fa\7\31\2\2\u02fa\u02fb\7\u00be\2\2\u02fb")
buf.write("\u02fc\7|\2\2\u02fc\u02fd\7\32\2\2\u02fd\u0309\7\u0083")
buf.write("\2\2\u02fe\u02ff\7\31\2\2\u02ff\u0300\7\u00be\2\2\u0300")
buf.write("\u0301\7|\2\2\u0301\u0309\5\32\16\2\u0302\u0303\7\31\2")
buf.write("\2\u0303\u0304\7\u00be\2\2\u0304\u0305\7|\2\2\u0305\u0306")
buf.write("\7\32\2\2\u0306\u0307\7\u0083\2\2\u0307\u0309\5\26\f\2")
buf.write("\u0308\u02f7\3\2\2\2\u0308\u02f9\3\2\2\2\u0308\u02fe\3")
buf.write("\2\2\2\u0308\u0302\3\2\2\2\u0309\25\3\2\2\2\u030a\u030f")
buf.write("\5\30\r\2\u030b\u030c\7|\2\2\u030c\u030e\5\30\r\2\u030d")
buf.write("\u030b\3\2\2\2\u030e\u0311\3\2\2\2\u030f\u030d\3\2\2\2")
buf.write("\u030f\u0310\3\2\2\2\u0310\27\3\2\2\2\u0311\u030f\3\2")
buf.write("\2\2\u0312\u0319\5\u00c8e\2\u0313\u0314\5\u012e\u0098")
buf.write("\2\u0314\u0315\7\33\2\2\u0315\u0316\5\36\20\2\u0316\u0319")
buf.write("\3\2\2\2\u0317\u0319\5\36\20\2\u0318\u0312\3\2\2\2\u0318")
buf.write("\u0313\3\2\2\2\u0318\u0317\3\2\2\2\u0319\31\3\2\2\2\u031a")
buf.write("\u031f\5\34\17\2\u031b\u031c\7|\2\2\u031c\u031e\5\34\17")
buf.write("\2\u031d\u031b\3\2\2\2\u031e\u0321\3\2\2\2\u031f\u031d")
buf.write("\3\2\2\2\u031f\u0320\3\2\2\2\u0320\33\3\2\2\2\u0321\u031f")
buf.write("\3\2\2\2\u0322\u0323\5\u012e\u0098\2\u0323\u0324\7\33")
buf.write("\2\2\u0324\u0325\5\36\20\2\u0325\35\3\2\2\2\u0326\u0327")
buf.write("\5\u012e\u0098\2\u0327\37\3\2\2\2\u0328\u0329\7.\2\2\u0329")
buf.write("\u032a\7}\2\2\u032a\u032b\5\"\22\2\u032b\u032c\7\u0082")
buf.write("\2\2\u032c!\3\2\2\2\u032d\u032f\5$\23\2\u032e\u032d\3")
buf.write("\2\2\2\u032f\u0330\3\2\2\2\u0330\u032e\3\2\2\2\u0330\u0331")
buf.write("\3\2\2\2\u0331#\3\2\2\2\u0332\u0333\7\u00be\2\2\u0333")
buf.write("\u0334\7\u0084\2\2\u0334\u0335\5\u0272\u013a\2\u0335%")
buf.write("\3\2\2\2\u0336\u033d\7\16\2\2\u0337\u0338\7\16\2\2\u0338")
buf.write("\u033a\7\7\2\2\u0339\u033b\7\u00be\2\2\u033a\u0339\3\2")
buf.write("\2\2\u033a\u033b\3\2\2\2\u033b\u033d\3\2\2\2\u033c\u0336")
buf.write("\3\2\2\2\u033c\u0337\3\2\2\2\u033d\'\3\2\2\2\u033e\u033f")
buf.write("\5*\26\2\u033f\u0340\5,\27\2\u0340\u0341\5\60\31\2\u0341")
buf.write("\u0346\3\2\2\2\u0342\u0343\5*\26\2\u0343\u0344\5\60\31")
buf.write("\2\u0344\u0346\3\2\2\2\u0345\u033e\3\2\2\2\u0345\u0342")
buf.write("\3\2\2\2\u0346)\3\2\2\2\u0347\u0349\7&\2\2\u0348\u034a")
buf.write("\7\u00be\2\2\u0349\u0348\3\2\2\2\u0349\u034a\3\2\2\2\u034a")
buf.write("\u0351\3\2\2\2\u034b\u034c\7\n\2\2\u034c\u034e\7\62\2")
buf.write("\2\u034d\u034f\7\u00be\2\2\u034e\u034d\3\2\2\2\u034e\u034f")
buf.write("\3\2\2\2\u034f\u0351\3\2\2\2\u0350\u0347\3\2\2\2\u0350")
buf.write("\u034b\3\2\2\2\u0351+\3\2\2\2\u0352\u0353\b\27\1\2\u0353")
buf.write("\u0354\5.\30\2\u0354\u0359\3\2\2\2\u0355\u0356\f\3\2\2")
buf.write("\u0356\u0358\5.\30\2\u0357\u0355\3\2\2\2\u0358\u035b\3")
buf.write("\2\2\2\u0359\u0357\3\2\2\2\u0359\u035a\3\2\2\2\u035a-")
buf.write("\3\2\2\2\u035b\u0359\3\2\2\2\u035c\u035d\5\22\n\2\u035d")
buf.write("/\3\2\2\2\u035e\u0360\7u\2\2\u035f\u0361\7\u00be\2\2\u0360")
buf.write("\u035f\3\2\2\2\u0360\u0361\3\2\2\2\u0361\u0374\3\2\2\2")
buf.write("\u0362\u0363\7\16\2\2\u0363\u0365\7&\2\2\u0364\u0366\7")
buf.write("\u00be\2\2\u0365\u0364\3\2\2\2\u0365\u0366\3\2\2\2\u0366")
buf.write("\u0374\3\2\2\2\u0367\u0368\7v\2\2\u0368\u036a\7\62\2\2")
buf.write("\u0369\u036b\7\u00be\2\2\u036a\u0369\3\2\2\2\u036a\u036b")
buf.write("\3\2\2\2\u036b\u0374\3\2\2\2\u036c\u036d\7\16\2\2\u036d")
buf.write("\u036e\7\n\2\2\u036e\u0370\7\62\2\2\u036f\u0371\7\u00be")
buf.write("\2\2\u0370\u036f\3\2\2\2\u0370\u0371\3\2\2\2\u0371\u0374")
buf.write("\3\2\2\2\u0372\u0374\7\16\2\2\u0373\u035e\3\2\2\2\u0373")
buf.write("\u0362\3\2\2\2\u0373\u0367\3\2\2\2\u0373\u036c\3\2\2\2")
buf.write("\u0373\u0372\3\2\2\2\u0374\61\3\2\2\2\u0375\u0376\7\u00bc")
buf.write("\2\2\u0376\u0377\7Z\2\2\u0377\u0379\7}\2\2\u0378\u037a")
buf.write("\5\64\33\2\u0379\u0378\3\2\2\2\u0379\u037a\3\2\2\2\u037a")
buf.write("\u037b\3\2\2\2\u037b\u037c\7\u0082\2\2\u037c\63\3\2\2")
buf.write("\2\u037d\u037e\b\33\1\2\u037e\u0383\5\66\34\2\u037f\u0383")
buf.write("\7\u0088\2\2\u0380\u0381\7\u0088\2\2\u0381\u0383\5\66")
buf.write("\34\2\u0382\u037d\3\2\2\2\u0382\u037f\3\2\2\2\u0382\u0380")
buf.write("\3\2\2\2\u0383\u0395\3\2\2\2\u0384\u0385\f\7\2\2\u0385")
buf.write("\u0394\7\u0088\2\2\u0386\u0387\f\6\2\2\u0387\u0388\7\u0088")
buf.write("\2\2\u0388\u0394\5\66\34\2\u0389\u038a\f\5\2\2\u038a\u038b")
buf.write("\7|\2\2\u038b\u0394\5\66\34\2\u038c\u038d\f\4\2\2\u038d")
buf.write("\u038e\7|\2\2\u038e\u0394\7\u0088\2\2\u038f\u0390\f\3")
buf.write("\2\2\u0390\u0391\7|\2\2\u0391\u0392\7\u0088\2\2\u0392")
buf.write("\u0394\5\66\34\2\u0393\u0384\3\2\2\2\u0393\u0386\3\2\2")
buf.write("\2\u0393\u0389\3\2\2\2\u0393\u038c\3\2\2\2\u0393\u038f")
buf.write("\3\2\2\2\u0394\u0397\3\2\2\2\u0395\u0393\3\2\2\2\u0395")
buf.write("\u0396\3\2\2\2\u0396\65\3\2\2\2\u0397\u0395\3\2\2\2\u0398")
buf.write("\u03a3\58\35\2\u0399\u039a\7\u00bc\2\2\u039a\u03a3\58")
buf.write("\35\2\u039b\u03a3\7\u0099\2\2\u039c\u03a3\7\u009a\2\2")
buf.write("\u039d\u039e\7\u009a\2\2\u039e\u03a3\58\35\2\u039f\u03a0")
buf.write("\7\u009a\2\2\u03a0\u03a1\7\u00bc\2\2\u03a1\u03a3\58\35")
buf.write("\2\u03a2\u0398\3\2\2\2\u03a2\u0399\3\2\2\2\u03a2\u039b")
buf.write("\3\2\2\2\u03a2\u039c\3\2\2\2\u03a2\u039d\3\2\2\2\u03a2")
buf.write("\u039f\3\2\2\2\u03a3\67\3\2\2\2\u03a4\u03ae\7\u009b\2")
buf.write("\2\u03a5\u03ae\5:\36\2\u03a6\u03ae\7\u00b3\2\2\u03a7\u03ae")
buf.write("\7\u009d\2\2\u03a8\u03ae\7\u00be\2\2\u03a9\u03aa\7}\2")
buf.write("\2\u03aa\u03ab\5\64\33\2\u03ab\u03ac\7\u0082\2\2\u03ac")
buf.write("\u03ae\3\2\2\2\u03ad\u03a4\3\2\2\2\u03ad\u03a5\3\2\2\2")
buf.write("\u03ad\u03a6\3\2\2\2\u03ad\u03a7\3\2\2\2\u03ad\u03a8\3")
buf.write("\2\2\2\u03ad\u03a9\3\2\2\2\u03ae9\3\2\2\2\u03af\u03b0")
buf.write("\7\u00b4\2\2\u03b0\u03b1\7\u00ba\2\2\u03b1\u03b2\7\u00b4")
buf.write("\2\2\u03b2\u03b8\7\u00bb\2\2\u03b3\u03b4\7\u00be\2\2\u03b4")
buf.write("\u03b5\7\u00ba\2\2\u03b5\u03b6\7\u00b4\2\2\u03b6\u03b8")
buf.write("\7\u00bb\2\2\u03b7\u03af\3\2\2\2\u03b7\u03b3\3\2\2\2\u03b8")
buf.write(";\3\2\2\2\u03b9\u03ba\5\u012a\u0096\2\u03ba\u03bb\5\u0130")
buf.write("\u0099\2\u03bb\u03bc\5> \2\u03bc\u03c1\3\2\2\2\u03bd\u03be")
buf.write("\5\u012a\u0096\2\u03be\u03bf\5> \2\u03bf\u03c1\3\2\2\2")
buf.write("\u03c0\u03b9\3\2\2\2\u03c0\u03bd\3\2\2\2\u03c1=\3\2\2")
buf.write("\2\u03c2\u03c3\7\16\2\2\u03c3\u03c5\7\5\2\2\u03c4\u03c6")
buf.write("\7\u00be\2\2\u03c5\u03c4\3\2\2\2\u03c5\u03c6\3\2\2\2\u03c6")
buf.write("\u03cd\3\2\2\2\u03c7\u03c9\7\6\2\2\u03c8\u03ca\7\u00be")
buf.write("\2\2\u03c9\u03c8\3\2\2\2\u03c9\u03ca\3\2\2\2\u03ca\u03cd")
buf.write("\3\2\2\2\u03cb\u03cd\7\16\2\2\u03cc\u03c2\3\2\2\2\u03cc")
buf.write("\u03c7\3\2\2\2\u03cc\u03cb\3\2\2\2\u03cd?\3\2\2\2\u03ce")
buf.write("\u03cf\7\b\2\2\u03cf\u03d0\7\u00be\2\2\u03d0\u03d1\5B")
buf.write("\"\2\u03d1\u03d2\79\2\2\u03d2\u03d3\7}\2\2\u03d3\u03d4")
buf.write("\7\u00be\2\2\u03d4\u03d5\7\u0082\2\2\u03d5A\3\2\2\2\u03d6")
buf.write("\u03d8\7}\2\2\u03d7\u03d9\5D#\2\u03d8\u03d7\3\2\2\2\u03d8")
buf.write("\u03d9\3\2\2\2\u03d9\u03da\3\2\2\2\u03da\u03dc\7\u0082")
buf.write("\2\2\u03db\u03d6\3\2\2\2\u03db\u03dc\3\2\2\2\u03dcC\3")
buf.write("\2\2\2\u03dd\u03e2\5F$\2\u03de\u03df\7|\2\2\u03df\u03e1")
buf.write("\5F$\2\u03e0\u03de\3\2\2\2\u03e1\u03e4\3\2\2\2\u03e2\u03e0")
buf.write("\3\2\2\2\u03e2\u03e3\3\2\2\2\u03e3E\3\2\2\2\u03e4\u03e2")
buf.write("\3\2\2\2\u03e5\u03e8\5l\67\2\u03e6\u03e8\7\u00c2\2\2\u03e7")
buf.write("\u03e5\3\2\2\2\u03e7\u03e6\3\2\2\2\u03e8G\3\2\2\2\u03e9")
buf.write("\u03ee\5\u00ecw\2\u03ea\u03ee\5\u00c2b\2\u03eb\u03ee\5")
buf.write("\u00aeX\2\u03ec\u03ee\5J&\2\u03ed\u03e9\3\2\2\2\u03ed")
buf.write("\u03ea\3\2\2\2\u03ed\u03eb\3\2\2\2\u03ed\u03ec\3\2\2\2")
buf.write("\u03eeI\3\2\2\2\u03ef\u03fe\5\u00a2R\2\u03f0\u03fe\5\u018a")
buf.write("\u00c6\2\u03f1\u03fe\5\u009eP\2\u03f2\u03fe\5\u0094K\2")
buf.write("\u03f3\u03fe\5\u008eH\2\u03f4\u03fe\5\u0088E\2\u03f5\u03fe")
buf.write("\5\u0080A\2\u03f6\u03fe\5x=\2\u03f7\u03fe\5p9\2\u03f8")
buf.write("\u03fe\5f\64\2\u03f9\u03fe\5^\60\2\u03fa\u03fe\5X-\2\u03fb")
buf.write("\u03fe\5R*\2\u03fc\u03fe\5L\'\2\u03fd\u03ef\3\2\2\2\u03fd")
buf.write("\u03f0\3\2\2\2\u03fd\u03f1\3\2\2\2\u03fd\u03f2\3\2\2\2")
buf.write("\u03fd\u03f3\3\2\2\2\u03fd\u03f4\3\2\2\2\u03fd\u03f5\3")
buf.write("\2\2\2\u03fd\u03f6\3\2\2\2\u03fd\u03f7\3\2\2\2\u03fd\u03f8")
buf.write("\3\2\2\2\u03fd\u03f9\3\2\2\2\u03fd\u03fa\3\2\2\2\u03fd")
buf.write("\u03fb\3\2\2\2\u03fd\u03fc\3\2\2\2\u03feK\3\2\2\2\u03ff")
buf.write("\u0401\7\20\2\2\u0400\u0402\7 \2\2\u0401\u0400\3\2\2\2")
buf.write("\u0401\u0402\3\2\2\2\u0402\u0403\3\2\2\2\u0403\u0404\5")
buf.write("N(\2\u0404M\3\2\2\2\u0405\u040a\5P)\2\u0406\u0407\7|\2")
buf.write("\2\u0407\u0409\5P)\2\u0408\u0406\3\2\2\2\u0409\u040c\3")
buf.write("\2\2\2\u040a\u0408\3\2\2\2\u040a\u040b\3\2\2\2\u040bO")
buf.write("\3\2\2\2\u040c\u040a\3\2\2\2\u040d\u0414\5\u00b8]\2\u040e")
buf.write("\u040f\5\u00b8]\2\u040f\u0410\7}\2\2\u0410\u0411\5\u00ba")
buf.write("^\2\u0411\u0412\7\u0082\2\2\u0412\u0414\3\2\2\2\u0413")
buf.write("\u040d\3\2\2\2\u0413\u040e\3\2\2\2\u0414Q\3\2\2\2\u0415")
buf.write("\u0417\7\'\2\2\u0416\u0418\7 \2\2\u0417\u0416\3\2\2\2")
buf.write("\u0417\u0418\3\2\2\2\u0418\u0419\3\2\2\2\u0419\u041a\5")
buf.write("T+\2\u041aS\3\2\2\2\u041b\u0420\5V,\2\u041c\u041d\7|\2")
buf.write("\2\u041d\u041f\5V,\2\u041e\u041c\3\2\2\2\u041f\u0422\3")
buf.write("\2\2\2\u0420\u041e\3\2\2\2\u0420\u0421\3\2\2\2\u0421U")
buf.write("\3\2\2\2\u0422\u0420\3\2\2\2\u0423\u042a\5\u00b8]\2\u0424")
buf.write("\u0425\5\u00b8]\2\u0425\u0426\7}\2\2\u0426\u0427\5\u010e")
buf.write("\u0088\2\u0427\u0428\7\u0082\2\2\u0428\u042a\3\2\2\2\u0429")
buf.write("\u0423\3\2\2\2\u0429\u0424\3\2\2\2\u042aW\3\2\2\2\u042b")
buf.write("\u042d\7\22\2\2\u042c\u042e\7 \2\2\u042d\u042c\3\2\2\2")
buf.write("\u042d\u042e\3\2\2\2\u042e\u042f\3\2\2\2\u042f\u0430\5")
buf.write("Z.\2\u0430Y\3\2\2\2\u0431\u0436\5\\/\2\u0432\u0433\7|")
buf.write("\2\2\u0433\u0435\5\\/\2\u0434\u0432\3\2\2\2\u0435\u0438")
buf.write("\3\2\2\2\u0436\u0434\3\2\2\2\u0436\u0437\3\2\2\2\u0437")
buf.write("[\3\2\2\2\u0438\u0436\3\2\2\2\u0439\u043a\5l\67\2\u043a")
buf.write("]\3\2\2\2\u043b\u043c\7\23\2\2\u043c\u043d\5`\61\2\u043d")
buf.write("_\3\2\2\2\u043e\u043f\b\61\1\2\u043f\u0440\7\u0087\2\2")
buf.write("\u0440\u0441\5b\62\2\u0441\u0442\7\u0087\2\2\u0442\u0443")
buf.write("\5d\63\2\u0443\u0456\3\2\2\2\u0444\u0445\f\5\2\2\u0445")
buf.write("\u0446\7\u0087\2\2\u0446\u0447\5b\62\2\u0447\u0448\7\u0087")
buf.write("\2\2\u0448\u0449\5d\63\2\u0449\u0455\3\2\2\2\u044a\u044b")
buf.write("\f\4\2\2\u044b\u044c\7|\2\2\u044c\u044d\7\u0087\2\2\u044d")
buf.write("\u044e\5b\62\2\u044e\u044f\7\u0087\2\2\u044f\u0450\5d")
buf.write("\63\2\u0450\u0455\3\2\2\2\u0451\u0452\f\3\2\2\u0452\u0453")
buf.write("\7|\2\2\u0453\u0455\5d\63\2\u0454\u0444\3\2\2\2\u0454")
buf.write("\u044a\3\2\2\2\u0454\u0451\3\2\2\2\u0455\u0458\3\2\2\2")
buf.write("\u0456\u0454\3\2\2\2\u0456\u0457\3\2\2\2\u0457a\3\2\2")
buf.write("\2\u0458\u0456\3\2\2\2\u0459\u045a\7\u00be\2\2\u045ac")
buf.write("\3\2\2\2\u045b\u045c\5\u01b2\u00da\2\u045ce\3\2\2\2\u045d")
buf.write("\u045e\7\24\2\2\u045e\u045f\7}\2\2\u045f\u0460\5n8\2\u0460")
buf.write("\u0462\7\u0082\2\2\u0461\u0463\7 \2\2\u0462\u0461\3\2")
buf.write("\2\2\u0462\u0463\3\2\2\2\u0463\u0464\3\2\2\2\u0464\u0465")
buf.write("\5h\65\2\u0465g\3\2\2\2\u0466\u0467\5j\66\2\u0467\u0468")
buf.write("\7|\2\2\u0468\u0469\5j\66\2\u0469i\3\2\2\2\u046a\u046b")
buf.write("\5l\67\2\u046bk\3\2\2\2\u046c\u046d\7\u00be\2\2\u046d")
buf.write("m\3\2\2\2\u046e\u046f\t\2\2\2\u046fo\3\2\2\2\u0470\u0472")
buf.write("\7\21\2\2\u0471\u0473\7 \2\2\u0472\u0471\3\2\2\2\u0472")
buf.write("\u0473\3\2\2\2\u0473\u0474\3\2\2\2\u0474\u0475\5r:\2\u0475")
buf.write("q\3\2\2\2\u0476\u047b\5t;\2\u0477\u0478\7|\2\2\u0478\u047a")
buf.write("\5t;\2\u0479\u0477\3\2\2\2\u047a\u047d\3\2\2\2\u047b\u0479")
buf.write("\3\2\2\2\u047b\u047c\3\2\2\2\u047cs\3\2\2\2\u047d\u047b")
buf.write("\3\2\2\2\u047e\u0485\5v<\2\u047f\u0480\5v<\2\u0480\u0481")
buf.write("\7}\2\2\u0481\u0482\5\u010e\u0088\2\u0482\u0483\7\u0082")
buf.write("\2\2\u0483\u0485\3\2\2\2\u0484\u047e\3\2\2\2\u0484\u047f")
buf.write("\3\2\2\2\u0485u\3\2\2\2\u0486\u0487\5\u012e\u0098\2\u0487")
buf.write("w\3\2\2\2\u0488\u048a\7*\2\2\u0489\u048b\7 \2\2\u048a")
buf.write("\u0489\3\2\2\2\u048a\u048b\3\2\2\2\u048b\u048c\3\2\2\2")
buf.write("\u048c\u048f\5z>\2\u048d\u048f\7*\2\2\u048e\u0488\3\2")
buf.write("\2\2\u048e\u048d\3\2\2\2\u048fy\3\2\2\2\u0490\u0495\5")
buf.write("|?\2\u0491\u0492\7|\2\2\u0492\u0494\5|?\2\u0493\u0491")
buf.write("\3\2\2\2\u0494\u0497\3\2\2\2\u0495\u0493\3\2\2\2\u0495")
buf.write("\u0496\3\2\2\2\u0496{\3\2\2\2\u0497\u0495\3\2\2\2\u0498")
buf.write("\u049b\5~@\2\u0499\u049b\5\u00c8e\2\u049a\u0498\3\2\2")
buf.write("\2\u049a\u0499\3\2\2\2\u049b}\3\2\2\2\u049c\u049d\5\u012e")
buf.write("\u0098\2\u049d\177\3\2\2\2\u049e\u04a5\7\61\2\2\u049f")
buf.write("\u04a0\7\61\2\2\u04a0\u04a5\5\u0082B\2\u04a1\u04a2\7\61")
buf.write("\2\2\u04a2\u04a3\7 \2\2\u04a3\u04a5\5\u0082B\2\u04a4\u049e")
buf.write("\3\2\2\2\u04a4\u049f\3\2\2\2\u04a4\u04a1\3\2\2\2\u04a5")
buf.write("\u0081\3\2\2\2\u04a6\u04a8\5\u0084C\2\u04a7\u04a6\3\2")
buf.write("\2\2\u04a8\u04a9\3\2\2\2\u04a9\u04a7\3\2\2\2\u04a9\u04aa")
buf.write("\3\2\2\2\u04aa\u0083\3\2\2\2\u04ab\u04ae\5\u01b2\u00da")
buf.write("\2\u04ac\u04ae\5\u0086D\2\u04ad\u04ab\3\2\2\2\u04ad\u04ac")
buf.write("\3\2\2\2\u04ae\u0085\3\2\2\2\u04af\u04b0\7\u0087\2\2\u04b0")
buf.write("\u04b1\5\u00acW\2\u04b1\u04b2\7\u0087\2\2\u04b2\u0087")
buf.write("\3\2\2\2\u04b3\u04b4\7\60\2\2\u04b4\u04b5\5\u008aF\2\u04b5")
buf.write("\u0089\3\2\2\2\u04b6\u04b8\5\u008cG\2\u04b7\u04b6\3\2")
buf.write("\2\2\u04b8\u04b9\3\2\2\2\u04b9\u04b7\3\2\2\2\u04b9\u04ba")
buf.write("\3\2\2\2\u04ba\u008b\3\2\2\2\u04bb\u04bc\7\u00be\2\2\u04bc")
buf.write("\u008d\3\2\2\2\u04bd\u04be\7/\2\2\u04be\u04bf\5\u0090")
buf.write("I\2\u04bf\u008f\3\2\2\2\u04c0\u04c2\5\u0092J\2\u04c1\u04c0")
buf.write("\3\2\2\2\u04c2\u04c3\3\2\2\2\u04c3\u04c1\3\2\2\2\u04c3")
buf.write("\u04c4\3\2\2\2\u04c4\u0091\3\2\2\2\u04c5\u04c6\7\u00be")
buf.write("\2\2\u04c6\u0093\3\2\2\2\u04c7\u04c8\7%\2\2\u04c8\u04c9")
buf.write("\5\u0096L\2\u04c9\u0095\3\2\2\2\u04ca\u04cc\5\u0098M\2")
buf.write("\u04cb\u04ca\3\2\2\2\u04cc\u04cd\3\2\2\2\u04cd\u04cb\3")
buf.write("\2\2\2\u04cd\u04ce\3\2\2\2\u04ce\u0097\3\2\2\2\u04cf\u04d0")
buf.write("\7}\2\2\u04d0\u04d1\5\u009aN\2\u04d1\u04d2\7|\2\2\u04d2")
buf.write("\u04d3\5\u009cO\2\u04d3\u04d4\7\u0082\2\2\u04d4\u0099")
buf.write("\3\2\2\2\u04d5\u04d6\5\u0196\u00cc\2\u04d6\u009b\3\2\2")
buf.write("\2\u04d7\u04d9\5\u009aN\2\u04d8\u04d7\3\2\2\2\u04d9\u04da")
buf.write("\3\2\2\2\u04da\u04d8\3\2\2\2\u04da\u04db\3\2\2\2\u04db")
buf.write("\u009d\3\2\2\2\u04dc\u04dd\7\17\2\2\u04dd\u04e2\5\u00a0")
buf.write("Q\2\u04de\u04df\7\17\2\2\u04df\u04e0\7 \2\2\u04e0\u04e2")
buf.write("\5\u00a0Q\2\u04e1\u04dc\3\2\2\2\u04e1\u04de\3\2\2\2\u04e2")
buf.write("\u009f\3\2\2\2\u04e3\u04e5\5\u00a8U\2\u04e4\u04e3\3\2")
buf.write("\2\2\u04e5\u04e6\3\2\2\2\u04e6\u04e4\3\2\2\2\u04e6\u04e7")
buf.write("\3\2\2\2\u04e7\u00a1\3\2\2\2\u04e8\u04e9\7\"\2\2\u04e9")
buf.write("\u04ea\5\u00a4S\2\u04ea\u00a3\3\2\2\2\u04eb\u04ed\bS\1")
buf.write("\2\u04ec\u04ee\5\u00aaV\2\u04ed\u04ec\3\2\2\2\u04ed\u04ee")
buf.write("\3\2\2\2\u04ee\u04ef\3\2\2\2\u04ef\u04f0\5\u00a6T\2\u04f0")
buf.write("\u04fd\3\2\2\2\u04f1\u04f2\f\4\2\2\u04f2\u04f4\7|\2\2")
buf.write("\u04f3\u04f5\5\u00aaV\2\u04f4\u04f3\3\2\2\2\u04f4\u04f5")
buf.write("\3\2\2\2\u04f5\u04f6\3\2\2\2\u04f6\u04fc\5\u00a6T\2\u04f7")
buf.write("\u04f8\f\3\2\2\u04f8\u04f9\5\u00aaV\2\u04f9\u04fa\5\u00a6")
buf.write("T\2\u04fa\u04fc\3\2\2\2\u04fb\u04f1\3\2\2\2\u04fb\u04f7")
buf.write("\3\2\2\2\u04fc\u04ff\3\2\2\2\u04fd\u04fb\3\2\2\2\u04fd")
buf.write("\u04fe\3\2\2\2\u04fe\u00a5\3\2\2\2\u04ff\u04fd\3\2\2\2")
buf.write("\u0500\u0503\5\u01b2\u00da\2\u0501\u0503\5\u00a8U\2\u0502")
buf.write("\u0500\3\2\2\2\u0502\u0501\3\2\2\2\u0503\u00a7\3\2\2\2")
buf.write("\u0504\u0505\5\u01b2\u00da\2\u0505\u0506\7}\2\2\u0506")
buf.write("\u0507\5\u00ba^\2\u0507\u0508\7\u0082\2\2\u0508\u00a9")
buf.write("\3\2\2\2\u0509\u050a\7\u0087\2\2\u050a\u050b\7\u00ba\2")
buf.write("\2\u050b\u050c\7\u0087\2\2\u050c\u0512\7\u00bb\2\2\u050d")
buf.write("\u050e\7\u0087\2\2\u050e\u050f\5\u00acW\2\u050f\u0510")
buf.write("\7\u0087\2\2\u0510\u0512\3\2\2\2\u0511\u0509\3\2\2\2\u0511")
buf.write("\u050d\3\2\2\2\u0512\u00ab\3\2\2\2\u0513\u0514\7\u00be")
buf.write("\2\2\u0514\u00ad\3\2\2\2\u0515\u0516\5\u0112\u008a\2\u0516")
buf.write("\u0517\5\u00b4[\2\u0517\u0520\3\2\2\2\u0518\u051a\5\u0112")
buf.write("\u008a\2\u0519\u051b\5\u00b0Y\2\u051a\u0519\3\2\2\2\u051a")
buf.write("\u051b\3\2\2\2\u051b\u051c\3\2\2\2\u051c\u051d\7 \2\2")
buf.write("\u051d\u051e\5\u00b4[\2\u051e\u0520\3\2\2\2\u051f\u0515")
buf.write("\3\2\2\2\u051f\u0518\3\2\2\2\u0520\u00af\3\2\2\2\u0521")
buf.write("\u0522\bY\1\2\u0522\u0523\7|\2\2\u0523\u0524\5\u00b2Z")
buf.write("\2\u0524\u052a\3\2\2\2\u0525\u0526\f\3\2\2\u0526\u0527")
buf.write("\7|\2\2\u0527\u0529\5\u00b2Z\2\u0528\u0525\3\2\2\2\u0529")
buf.write("\u052c\3\2\2\2\u052a\u0528\3\2\2\2\u052a\u052b\3\2\2\2")
buf.write("\u052b\u00b1\3\2\2\2\u052c\u052a\3\2\2\2\u052d\u0541\7")
buf.write(".\2\2\u052e\u0541\7*\2\2\u052f\u0541\7\21\2\2\u0530\u0531")
buf.write("\7\17\2\2\u0531\u0532\7}\2\2\u0532\u0533\5\u00ba^\2\u0533")
buf.write("\u0534\7\u0082\2\2\u0534\u0541\3\2\2\2\u0535\u0541\7/")
buf.write("\2\2\u0536\u0537\7\24\2\2\u0537\u0538\7}\2\2\u0538\u0539")
buf.write("\5n8\2\u0539\u053a\7\u0082\2\2\u053a\u0541\3\2\2\2\u053b")
buf.write("\u0541\7\60\2\2\u053c\u0541\7\22\2\2\u053d\u0541\7\'\2")
buf.write("\2\u053e\u0541\7\61\2\2\u053f\u0541\7\20\2\2\u0540\u052d")
buf.write("\3\2\2\2\u0540\u052e\3\2\2\2\u0540\u052f\3\2\2\2\u0540")
buf.write("\u0530\3\2\2\2\u0540\u0535\3\2\2\2\u0540\u0536\3\2\2\2")
buf.write("\u0540\u053b\3\2\2\2\u0540\u053c\3\2\2\2\u0540\u053d\3")
buf.write("\2\2\2\u0540\u053e\3\2\2\2\u0540\u053f\3\2\2\2\u0541\u00b3")
buf.write("\3\2\2\2\u0542\u0547\5\u00b6\\\2\u0543\u0544\7|\2\2\u0544")
buf.write("\u0546\5\u00b6\\\2\u0545\u0543\3\2\2\2\u0546\u0549\3\2")
buf.write("\2\2\u0547\u0545\3\2\2\2\u0547\u0548\3\2\2\2\u0548\u00b5")
buf.write("\3\2\2\2\u0549\u0547\3\2\2\2\u054a\u0576\5\u00b8]\2\u054b")
buf.write("\u054c\5\u00b8]\2\u054c\u054d\7}\2\2\u054d\u054e\5\u00ba")
buf.write("^\2\u054e\u054f\7\u0082\2\2\u054f\u0576\3\2\2\2\u0550")
buf.write("\u0551\5\u00b8]\2\u0551\u0552\7\u00c2\2\2\u0552\u0553")
buf.write("\5\u011c\u008f\2\u0553\u0576\3\2\2\2\u0554\u0555\5\u00b8")
buf.write("]\2\u0555\u0556\7}\2\2\u0556\u0557\5\u00ba^\2\u0557\u0558")
buf.write("\7\u0082\2\2\u0558\u0559\7\u00c2\2\2\u0559\u055a\5\u011c")
buf.write("\u008f\2\u055a\u0576\3\2\2\2\u055b\u055c\5\u00b8]\2\u055c")
buf.write("\u055d\7\u0084\2\2\u055d\u055e\5\u0272\u013a\2\u055e\u0576")
buf.write("\3\2\2\2\u055f\u0560\5\u00b8]\2\u0560\u0561\7}\2\2\u0561")
buf.write("\u0562\5\u00ba^\2\u0562\u0563\7\u0082\2\2\u0563\u0564")
buf.write("\7\u0084\2\2\u0564\u0565\5\u0272\u013a\2\u0565\u0576\3")
buf.write("\2\2\2\u0566\u0567\5\u00b8]\2\u0567\u0568\7\u00c2\2\2")
buf.write("\u0568\u0569\5\u011c\u008f\2\u0569\u056a\7\u0084\2\2\u056a")
buf.write("\u056b\5\u0272\u013a\2\u056b\u0576\3\2\2\2\u056c\u056d")
buf.write("\5\u00b8]\2\u056d\u056e\7\u00c2\2\2\u056e\u056f\5\u011c")
buf.write("\u008f\2\u056f\u0570\7}\2\2\u0570\u0571\5\u00ba^\2\u0571")
buf.write("\u0572\7\u0082\2\2\u0572\u0573\7\u0084\2\2\u0573\u0574")
buf.write("\5\u0272\u013a\2\u0574\u0576\3\2\2\2\u0575\u054a\3\2\2")
buf.write("\2\u0575\u054b\3\2\2\2\u0575\u0550\3\2\2\2\u0575\u0554")
buf.write("\3\2\2\2\u0575\u055b\3\2\2\2\u0575\u055f\3\2\2\2\u0575")
buf.write("\u0566\3\2\2\2\u0575\u056c\3\2\2\2\u0576\u00b7\3\2\2\2")
buf.write("\u0577\u0578\7\u00be\2\2\u0578\u00b9\3\2\2\2\u0579\u057e")
buf.write("\5\u0106\u0084\2\u057a\u057e\5\u00c0a\2\u057b\u057e\5")
buf.write("\u00bc_\2\u057c\u057e\5\u010e\u0088\2\u057d\u0579\3\2")
buf.write("\2\2\u057d\u057a\3\2\2\2\u057d\u057b\3\2\2\2\u057d\u057c")
buf.write("\3\2\2\2\u057e\u00bb\3\2\2\2\u057f\u0580\b_\1\2\u0580")
buf.write("\u0581\5\u010a\u0086\2\u0581\u0582\7\u0083\2\2\u0582\u0589")
buf.write("\3\2\2\2\u0583\u0584\5\u010e\u0088\2\u0584\u0585\7|\2")
buf.write("\2\u0585\u0586\5\u010a\u0086\2\u0586\u0587\7\u0083\2\2")
buf.write("\u0587\u0589\3\2\2\2\u0588\u057f\3\2\2\2\u0588\u0583\3")
buf.write("\2\2\2\u0589\u058f\3\2\2\2\u058a\u058b\f\3\2\2\u058b\u058c")
buf.write("\7|\2\2\u058c\u058e\5\u00be`\2\u058d\u058a\3\2\2\2\u058e")
buf.write("\u0591\3\2\2\2\u058f\u058d\3\2\2\2\u058f\u0590\3\2\2\2")
buf.write("\u0590\u00bd\3\2\2\2\u0591\u058f\3\2\2\2\u0592\u0593\5")
buf.write("\u010a\u0086\2\u0593\u0594\7\u0083\2\2\u0594\u0597\3\2")
buf.write("\2\2\u0595\u0597\7\u0083\2\2\u0596\u0592\3\2\2\2\u0596")
buf.write("\u0595\3\2\2\2\u0597\u00bf\3\2\2\2\u0598\u05a8\7\u00c2")
buf.write("\2\2\u0599\u059a\5\u010a\u0086\2\u059a\u059b\7\u0083\2")
buf.write("\2\u059b\u059c\7\u00c2\2\2\u059c\u05a8\3\2\2\2\u059d\u059e")
buf.write("\5\u0106\u0084\2\u059e\u059f\7|\2\2\u059f\u05a0\7\u00c2")
buf.write("\2\2\u05a0\u05a8\3\2\2\2\u05a1\u05a2\5\u0106\u0084\2\u05a2")
buf.write("\u05a3\7|\2\2\u05a3\u05a4\5\u010a\u0086\2\u05a4\u05a5")
buf.write("\7\u0083\2\2\u05a5\u05a6\7\u00c2\2\2\u05a6\u05a8\3\2\2")
buf.write("\2\u05a7\u0598\3\2\2\2\u05a7\u0599\3\2\2\2\u05a7\u059d")
buf.write("\3\2\2\2\u05a7\u05a1\3\2\2\2\u05a8\u00c1\3\2\2\2\u05a9")
buf.write("\u05aa\5\u00c6d\2\u05aa\u05ab\5\u00ccg\2\u05ab\u05ac\5")
buf.write("\u00c4c\2\u05ac\u00c3\3\2\2\2\u05ad\u05b1\7\f\2\2\u05ae")
buf.write("\u05af\7\16\2\2\u05af\u05b1\7\u00b9\2\2\u05b0\u05ad\3")
buf.write("\2\2\2\u05b0\u05ae\3\2\2\2\u05b1\u05b3\3\2\2\2\u05b2\u05b4")
buf.write("\7\u00be\2\2\u05b3\u05b2\3\2\2\2\u05b3\u05b4\3\2\2\2\u05b4")
buf.write("\u00c5\3\2\2\2\u05b5\u05b6\7\u00b9\2\2\u05b6\u05bb\7\u00be")
buf.write("\2\2\u05b7\u05b8\7\u00b9\2\2\u05b8\u05bb\5\u00c8e\2\u05b9")
buf.write("\u05bb\7\u00b9\2\2\u05ba\u05b5\3\2\2\2\u05ba\u05b7\3\2")
buf.write("\2\2\u05ba\u05b9\3\2\2\2\u05bb\u00c7\3\2\2\2\u05bc\u05bd")
buf.write("\7\30\2\2\u05bd\u05be\7}\2\2\u05be\u05bf\5\u00caf\2\u05bf")
buf.write("\u05c0\7\u0082\2\2\u05c0\u05c6\3\2\2\2\u05c1\u05c2\7\34")
buf.write("\2\2\u05c2\u05c3\7}\2\2\u05c3\u05c4\7\u0084\2\2\u05c4")
buf.write("\u05c6\7\u0082\2\2\u05c5\u05bc\3\2\2\2\u05c5\u05c1\3\2")
buf.write("\2\2\u05c6\u00c9\3\2\2\2\u05c7\u05d5\7\35\2\2\u05c8\u05d5")
buf.write("\7\u0089\2\2\u05c9\u05d5\7\u00c2\2\2\u05ca\u05d5\t\3\2")
buf.write("\2\u05cb\u05d5\t\4\2\2\u05cc\u05cd\7\u0087\2\2\u05cd\u05ce")
buf.write("\7\u00ba\2\2\u05ce\u05cf\7\u0087\2\2\u05cf\u05d5\7\u00bb")
buf.write("\2\2\u05d0\u05d5\7\u008a\2\2\u05d1\u05d5\7\u008b\2\2\u05d2")
buf.write("\u05d5\7\u008c\2\2\u05d3\u05d5\t\5\2\2\u05d4\u05c7\3\2")
buf.write("\2\2\u05d4\u05c8\3\2\2\2\u05d4\u05c9\3\2\2\2\u05d4\u05ca")
buf.write("\3\2\2\2\u05d4\u05cb\3\2\2\2\u05d4\u05cc\3\2\2\2\u05d4")
buf.write("\u05d0\3\2\2\2\u05d4\u05d1\3\2\2\2\u05d4\u05d2\3\2\2\2")
buf.write("\u05d4\u05d3\3\2\2\2\u05d5\u00cb\3\2\2\2\u05d6\u05d7\b")
buf.write("g\1\2\u05d7\u05d8\5\u00ceh\2\u05d8\u05dd\3\2\2\2\u05d9")
buf.write("\u05da\f\3\2\2\u05da\u05dc\5\u00ceh\2\u05db\u05d9\3\2")
buf.write("\2\2\u05dc\u05df\3\2\2\2\u05dd\u05db\3\2\2\2\u05dd\u05de")
buf.write("\3\2\2\2\u05de\u00cd\3\2\2\2\u05df\u05dd\3\2\2\2\u05e0")
buf.write("\u05e3\5\u00d6l\2\u05e1\u05e3\5\u00d0i\2\u05e2\u05e0\3")
buf.write("\2\2\2\u05e2\u05e1\3\2\2\2\u05e3\u00cf\3\2\2\2\u05e4\u05e5")
buf.write("\7\5\2\2\u05e5\u05e6\7\r\2\2\u05e6\u05e7\5\u00d2j\2\u05e7")
buf.write("\u00d1\3\2\2\2\u05e8\u05ed\5\u00d4k\2\u05e9\u05ea\7|\2")
buf.write("\2\u05ea\u05ec\5\u00d4k\2\u05eb\u05e9\3\2\2\2\u05ec\u05ef")
buf.write("\3\2\2\2\u05ed\u05eb\3\2\2\2\u05ed\u05ee\3\2\2\2\u05ee")
buf.write("\u00d3\3\2\2\2\u05ef\u05ed\3\2\2\2\u05f0\u05f1\5\u012e")
buf.write("\u0098\2\u05f1\u00d5\3\2\2\2\u05f2\u05f3\5\u00dep\2\u05f3")
buf.write("\u05f4\7\u00be\2\2\u05f4\u05f5\5\u00e0q\2\u05f5\u05fa")
buf.write("\3\2\2\2\u05f6\u05f7\7\13\2\2\u05f7\u05f8\7\u00be\2\2")
buf.write("\u05f8\u05fa\5\u00d8m\2\u05f9\u05f2\3\2\2\2\u05f9\u05f6")
buf.write("\3\2\2\2\u05fa\u00d7\3\2\2\2\u05fb\u05fd\5B\"\2\u05fc")
buf.write("\u05fe\5\u00e8u\2\u05fd\u05fc\3\2\2\2\u05fd\u05fe\3\2")
buf.write("\2\2\u05fe\u05ff\3\2\2\2\u05ff\u0600\5\u00dan\2\u0600")
buf.write("\u00d9\3\2\2\2\u0601\u0608\7\16\2\2\u0602\u0603\7\16\2")
buf.write("\2\u0603\u0605\7\13\2\2\u0604\u0606\7\u00be\2\2\u0605")
buf.write("\u0604\3\2\2\2\u0605\u0606\3\2\2\2\u0606\u0608\3\2\2\2")
buf.write("\u0607\u0601\3\2\2\2\u0607\u0602\3\2\2\2\u0608\u00db\3")
buf.write("\2\2\2\u0609\u060a\7\3\2\2\u060a\u00dd\3\2\2\2\u060b\u060d")
buf.write("\5\u00dco\2\u060c\u060b\3\2\2\2\u060c\u060d\3\2\2\2\u060d")
buf.write("\u060f\3\2\2\2\u060e\u0610\5\u0112\u008a\2\u060f\u060e")
buf.write("\3\2\2\2\u060f\u0610\3\2\2\2\u0610\u0611\3\2\2\2\u0611")
buf.write("\u0617\7\t\2\2\u0612\u0613\5\u0112\u008a\2\u0613\u0614")
buf.write("\7\3\2\2\u0614\u0615\7\t\2\2\u0615\u0617\3\2\2\2\u0616")
buf.write("\u060c\3\2\2\2\u0616\u0612\3\2\2\2\u0617\u00df\3\2\2\2")
buf.write("\u0618\u061a\5\u00e2r\2\u0619\u061b\5\u00e8u\2\u061a\u0619")
buf.write("\3\2\2\2\u061a\u061b\3\2\2\2\u061b\u061c\3\2\2\2\u061c")
buf.write("\u061d\5\u00eav\2\u061d\u00e1\3\2\2\2\u061e\u0620\7}\2")
buf.write("\2\u061f\u0621\5\u00e4s\2\u0620\u061f\3\2\2\2\u0620\u0621")
buf.write("\3\2\2\2\u0621\u0622\3\2\2\2\u0622\u0623\7\u0082\2\2\u0623")
buf.write("\u00e3\3\2\2\2\u0624\u0629\5\u00e6t\2\u0625\u0626\7|\2")
buf.write("\2\u0626\u0628\5\u00e6t\2\u0627\u0625\3\2\2\2\u0628\u062b")
buf.write("\3\2\2\2\u0629\u0627\3\2\2\2\u0629\u062a\3\2\2\2\u062a")
buf.write("\u00e5\3\2\2\2\u062b\u0629\3\2\2\2\u062c\u062d\5l\67\2")
buf.write("\u062d\u00e7\3\2\2\2\u062e\u062f\bu\1\2\u062f\u0630\5")
buf.write("\22\n\2\u0630\u0635\3\2\2\2\u0631\u0632\f\3\2\2\u0632")
buf.write("\u0634\5\22\n\2\u0633\u0631\3\2\2\2\u0634\u0637\3\2\2")
buf.write("\2\u0635\u0633\3\2\2\2\u0635\u0636\3\2\2\2\u0636\u00e9")
buf.write("\3\2\2\2\u0637\u0635\3\2\2\2\u0638\u063f\7\16\2\2\u0639")
buf.write("\u063a\7\16\2\2\u063a\u063c\7\t\2\2\u063b\u063d\7\u00be")
buf.write("\2\2\u063c\u063b\3\2\2\2\u063c\u063d\3\2\2\2\u063d\u063f")
buf.write("\3\2\2\2\u063e\u0638\3\2\2\2\u063e\u0639\3\2\2\2\u063f")
buf.write("\u00eb\3\2\2\2\u0640\u0641\5\u00f0y\2\u0641\u0642\5\u00f2")
buf.write("z\2\u0642\u0643\5\u00eex\2\u0643\u00ed\3\2\2\2\u0644\u0645")
buf.write("\7\u00b8\2\2\u0645\u064d\7\u00be\2\2\u0646\u064d\7\u00b8")
buf.write("\2\2\u0647\u0648\7\16\2\2\u0648\u0649\7\u00bd\2\2\u0649")
buf.write("\u064d\7\u00be\2\2\u064a\u064b\7\16\2\2\u064b\u064d\7")
buf.write("\u00bd\2\2\u064c\u0644\3\2\2\2\u064c\u0646\3\2\2\2\u064c")
buf.write("\u0647\3\2\2\2\u064c\u064a\3\2\2\2\u064d\u00ef\3\2\2\2")
buf.write("\u064e\u064f\7\u00bd\2\2\u064f\u0659\7\u00be\2\2\u0650")
buf.write("\u0651\7\u00bd\2\2\u0651\u0652\7 \2\2\u0652\u0659\7\u00be")
buf.write("\2\2\u0653\u0654\7\u00bd\2\2\u0654\u0655\7|\2\2\u0655")
buf.write("\u0656\7*\2\2\u0656\u0657\7 \2\2\u0657\u0659\7\u00be\2")
buf.write("\2\u0658\u064e\3\2\2\2\u0658\u0650\3\2\2\2\u0658\u0653")
buf.write("\3\2\2\2\u0659\u00f1\3\2\2\2\u065a\u065b\bz\1\2\u065b")
buf.write("\u065c\5\u00f4{\2\u065c\u0661\3\2\2\2\u065d\u065e\f\3")
buf.write("\2\2\u065e\u0660\5\u00f4{\2\u065f\u065d\3\2\2\2\u0660")
buf.write("\u0663\3\2\2\2\u0661\u065f\3\2\2\2\u0661\u0662\3\2\2\2")
buf.write("\u0662\u00f3\3\2\2\2\u0663\u0661\3\2\2\2\u0664\u0667\5")
buf.write("\u00f6|\2\u0665\u0667\5\u00f8}\2\u0666\u0664\3\2\2\2\u0666")
buf.write("\u0665\3\2\2\2\u0667\u00f5\3\2\2\2\u0668\u0669\t\6\2\2")
buf.write("\u0669\u00f7\3\2\2\2\u066a\u066b\5\u0112\u008a\2\u066b")
buf.write("\u066c\7|\2\2\u066c\u066d\5\u0100\u0081\2\u066d\u066e")
buf.write("\7 \2\2\u066e\u066f\5\u00fa~\2\u066f\u0678\3\2\2\2\u0670")
buf.write("\u0671\5\u0112\u008a\2\u0671\u0672\7 \2\2\u0672\u0673")
buf.write("\5\u00fa~\2\u0673\u0678\3\2\2\2\u0674\u0675\5\u0112\u008a")
buf.write("\2\u0675\u0676\5\u00fa~\2\u0676\u0678\3\2\2\2\u0677\u066a")
buf.write("\3\2\2\2\u0677\u0670\3\2\2\2\u0677\u0674\3\2\2\2\u0678")
buf.write("\u00f9\3\2\2\2\u0679\u067e\5\u00fc\177\2\u067a\u067b\7")
buf.write("|\2\2\u067b\u067d\5\u00fc\177\2\u067c\u067a\3\2\2\2\u067d")
buf.write("\u0680\3\2\2\2\u067e\u067c\3\2\2\2\u067e\u067f\3\2\2\2")
buf.write("\u067f\u00fb\3\2\2\2\u0680\u067e\3\2\2\2\u0681\u0682\5")
buf.write("\u00fe\u0080\2\u0682\u0683\7}\2\2\u0683\u0684\5\u0104")
buf.write("\u0083\2\u0684\u0685\7\u0082\2\2\u0685\u0686\7\u00c2\2")
buf.write("\2\u0686\u0687\5\u011c\u008f\2\u0687\u06ad\3\2\2\2\u0688")
buf.write("\u0689\5\u00fe\u0080\2\u0689\u068a\7}\2\2\u068a\u068b")
buf.write("\5\u0104\u0083\2\u068b\u068c\7\u0082\2\2\u068c\u068d\7")
buf.write("\u0084\2\2\u068d\u068e\5\u0272\u013a\2\u068e\u06ad\3\2")
buf.write("\2\2\u068f\u0690\5\u00fe\u0080\2\u0690\u0691\7}\2\2\u0691")
buf.write("\u0692\5\u0104\u0083\2\u0692\u0693\7\u0082\2\2\u0693\u06ad")
buf.write("\3\2\2\2\u0694\u0695\5\u00fe\u0080\2\u0695\u0696\7\u00c2")
buf.write("\2\2\u0696\u0697\5\u011c\u008f\2\u0697\u06ad\3\2\2\2\u0698")
buf.write("\u0699\5\u00fe\u0080\2\u0699\u069a\7\u0084\2\2\u069a\u069b")
buf.write("\5\u0272\u013a\2\u069b\u06ad\3\2\2\2\u069c\u069d\5\u00fe")
buf.write("\u0080\2\u069d\u069e\7\u00c2\2\2\u069e\u069f\5\u011c\u008f")
buf.write("\2\u069f\u06a0\7\u0084\2\2\u06a0\u06a1\5\u0272\u013a\2")
buf.write("\u06a1\u06ad\3\2\2\2\u06a2\u06a3\5\u00fe\u0080\2\u06a3")
buf.write("\u06a4\7\u00c2\2\2\u06a4\u06a5\5\u011c\u008f\2\u06a5\u06a6")
buf.write("\7}\2\2\u06a6\u06a7\5\u0104\u0083\2\u06a7\u06a8\7\u0082")
buf.write("\2\2\u06a8\u06a9\7\u0084\2\2\u06a9\u06aa\5\u0272\u013a")
buf.write("\2\u06aa\u06ad\3\2\2\2\u06ab\u06ad\5\u00fe\u0080\2\u06ac")
buf.write("\u0681\3\2\2\2\u06ac\u0688\3\2\2\2\u06ac\u068f\3\2\2\2")
buf.write("\u06ac\u0694\3\2\2\2\u06ac\u0698\3\2\2\2\u06ac\u069c\3")
buf.write("\2\2\2\u06ac\u06a2\3\2\2\2\u06ac\u06ab\3\2\2\2\u06ad\u00fd")
buf.write("\3\2\2\2\u06ae\u06af\7\u00be\2\2\u06af\u00ff\3\2\2\2\u06b0")
buf.write("\u06b5\5\u0102\u0082\2\u06b1\u06b2\7|\2\2\u06b2\u06b4")
buf.write("\5\u0102\u0082\2\u06b3\u06b1\3\2\2\2\u06b4\u06b7\3\2\2")
buf.write("\2\u06b5\u06b3\3\2\2\2\u06b5\u06b6\3\2\2\2\u06b6\u0101")
buf.write("\3\2\2\2\u06b7\u06b5\3\2\2\2\u06b8\u06bf\7\'\2\2\u06b9")
buf.write("\u06ba\7\17\2\2\u06ba\u06bb\7}\2\2\u06bb\u06bc\5\u0104")
buf.write("\u0083\2\u06bc\u06bd\7\u0082\2\2\u06bd\u06bf\3\2\2\2\u06be")
buf.write("\u06b8\3\2\2\2\u06be\u06b9\3\2\2\2\u06bf\u0103\3\2\2\2")
buf.write("\u06c0\u06c3\5\u0106\u0084\2\u06c1\u06c3\5\u010e\u0088")
buf.write("\2\u06c2\u06c0\3\2\2\2\u06c2\u06c1\3\2\2\2\u06c3\u0105")
buf.write("\3\2\2\2\u06c4\u06c9\5\u0108\u0085\2\u06c5\u06c6\7|\2")
buf.write("\2\u06c6\u06c8\5\u0108\u0085\2\u06c7\u06c5\3\2\2\2\u06c8")
buf.write("\u06cb\3\2\2\2\u06c9\u06c7\3\2\2\2\u06c9\u06ca\3\2\2\2")
buf.write("\u06ca\u0107\3\2\2\2\u06cb\u06c9\3\2\2\2\u06cc\u06cd\5")
buf.write("\u010a\u0086\2\u06cd\u06ce\7\u0083\2\2\u06ce\u06cf\5\u010c")
buf.write("\u0087\2\u06cf\u06d2\3\2\2\2\u06d0\u06d2\5\u010c\u0087")
buf.write("\2\u06d1\u06cc\3\2\2\2\u06d1\u06d0\3\2\2\2\u06d2\u0109")
buf.write("\3\2\2\2\u06d3\u06d4\5\u0272\u013a\2\u06d4\u010b\3\2\2")
buf.write("\2\u06d5\u06d6\5\u0272\u013a\2\u06d6\u010d\3\2\2\2\u06d7")
buf.write("\u06dc\5\u0110\u0089\2\u06d8\u06d9\7|\2\2\u06d9\u06db")
buf.write("\5\u0110\u0089\2\u06da\u06d8\3\2\2\2\u06db\u06de\3\2\2")
buf.write("\2\u06dc\u06da\3\2\2\2\u06dc\u06dd\3\2\2\2\u06dd\u010f")
buf.write("\3\2\2\2\u06de\u06dc\3\2\2\2\u06df\u06e0\7\u0083\2\2\u06e0")
buf.write("\u0111\3\2\2\2\u06e1\u06fb\7\u00aa\2\2\u06e2\u06fb\7$")
buf.write("\2\2\u06e3\u06fb\7\37\2\2\u06e4\u06fb\7\u00a8\2\2\u06e5")
buf.write("\u06fb\7\u00ab\2\2\u06e6\u06fb\7-\2\2\u06e7\u06e8\7-\2")
buf.write("\2\u06e8\u06fb\5\u011a\u008e\2\u06e9\u06ea\7\u00aa\2\2")
buf.write("\u06ea\u06fb\5\u0114\u008b\2\u06eb\u06ec\7$\2\2\u06ec")
buf.write("\u06fb\5\u0114\u008b\2\u06ed\u06ee\7_\2\2\u06ee\u06fb")
buf.write("\7\u00a9\2\2\u06ef\u06f0\7\u00a8\2\2\u06f0\u06fb\5\u0114")
buf.write("\u008b\2\u06f1\u06f2\7-\2\2\u06f2\u06fb\5\u0118\u008d")
buf.write("\2\u06f3\u06f4\7\u00ab\2\2\u06f4\u06fb\5\u0114\u008b\2")
buf.write("\u06f5\u06f6\7\u00bd\2\2\u06f6\u06f7\7}\2\2\u06f7\u06f8")
buf.write("\5\u0116\u008c\2\u06f8\u06f9\7\u0082\2\2\u06f9\u06fb\3")
buf.write("\2\2\2\u06fa\u06e1\3\2\2\2\u06fa\u06e2\3\2\2\2\u06fa\u06e3")
buf.write("\3\2\2\2\u06fa\u06e4\3\2\2\2\u06fa\u06e5\3\2\2\2\u06fa")
buf.write("\u06e6\3\2\2\2\u06fa\u06e7\3\2\2\2\u06fa\u06e9\3\2\2\2")
buf.write("\u06fa\u06eb\3\2\2\2\u06fa\u06ed\3\2\2\2\u06fa\u06ef\3")
buf.write("\2\2\2\u06fa\u06f1\3\2\2\2\u06fa\u06f3\3\2\2\2\u06fa\u06f5")
buf.write("\3\2\2\2\u06fb\u0113\3\2\2\2\u06fc\u06fd\7}\2\2\u06fd")
buf.write("\u06fe\7w\2\2\u06fe\u06ff\7\u0084\2\2\u06ff\u0700\5\u0272")
buf.write("\u013a\2\u0700\u0701\7\u0082\2\2\u0701\u0707\3\2\2\2\u0702")
buf.write("\u0703\7}\2\2\u0703\u0704\5\u0272\u013a\2\u0704\u0705")
buf.write("\7\u0082\2\2\u0705\u0707\3\2\2\2\u0706\u06fc\3\2\2\2\u0706")
buf.write("\u0702\3\2\2\2\u0707\u0115\3\2\2\2\u0708\u0709\5\u012e")
buf.write("\u0098\2\u0709\u0117\3\2\2\2\u070a\u070b\7}\2\2\u070b")
buf.write("\u070c\7x\2\2\u070c\u070d\7\u0084\2\2\u070d\u070e\5\u0128")
buf.write("\u0095\2\u070e\u070f\7|\2\2\u070f\u0710\7w\2\2\u0710\u0711")
buf.write("\7\u0084\2\2\u0711\u0712\5\u0272\u013a\2\u0712\u0713\7")
buf.write("\u0082\2\2\u0713\u072d\3\2\2\2\u0714\u0715\7}\2\2\u0715")
buf.write("\u0716\7x\2\2\u0716\u0717\7\u0084\2\2\u0717\u0718\5\u0128")
buf.write("\u0095\2\u0718\u0719\7|\2\2\u0719\u071a\5\u0272\u013a")
buf.write("\2\u071a\u071b\7\u0082\2\2\u071b\u072d\3\2\2\2\u071c\u071d")
buf.write("\7}\2\2\u071d\u071e\7x\2\2\u071e\u071f\7\u0084\2\2\u071f")
buf.write("\u0720\5\u0128\u0095\2\u0720\u0721\7\u0082\2\2\u0721\u072d")
buf.write("\3\2\2\2\u0722\u0723\7}\2\2\u0723\u0724\7w\2\2\u0724\u0725")
buf.write("\7\u0084\2\2\u0725\u0726\5\u0272\u013a\2\u0726\u0727\7")
buf.write("\u0082\2\2\u0727\u072d\3\2\2\2\u0728\u0729\7}\2\2\u0729")
buf.write("\u072a\5\u0272\u013a\2\u072a\u072b\7\u0082\2\2\u072b\u072d")
buf.write("\3\2\2\2\u072c\u070a\3\2\2\2\u072c\u0714\3\2\2\2\u072c")
buf.write("\u071c\3\2\2\2\u072c\u0722\3\2\2\2\u072c\u0728\3\2\2\2")
buf.write("\u072d\u0119\3\2\2\2\u072e\u072f\7\u00c2\2\2\u072f\u0735")
buf.write("\5\u011c\u008f\2\u0730\u0731\7}\2\2\u0731\u0732\5\u0128")
buf.write("\u0095\2\u0732\u0733\7\u0082\2\2\u0733\u0735\3\2\2\2\u0734")
buf.write("\u072e\3\2\2\2\u0734\u0730\3\2\2\2\u0735\u011b\3\2\2\2")
buf.write("\u0736\u0737\7}\2\2\u0737\u0738\5\u0128\u0095\2\u0738")
buf.write("\u0739\7\u0082\2\2\u0739\u073c\3\2\2\2\u073a\u073c\5\u011e")
buf.write("\u0090\2\u073b\u0736\3\2\2\2\u073b\u073a\3\2\2\2\u073c")
buf.write("\u011d\3\2\2\2\u073d\u074f\5\u0126\u0094\2\u073e\u0740")
buf.write("\t\3\2\2\u073f\u073e\3\2\2\2\u073f\u0740\3\2\2\2\u0740")
buf.write("\u0741\3\2\2\2\u0741\u074f\5\u02b0\u0159\2\u0742\u074f")
buf.write("\7\u00b3\2\2\u0743\u074f\7\u009d\2\2\u0744\u074f\5\u02ac")
buf.write("\u0157\2\u0745\u0746\7\u00bc\2\2\u0746\u0747\7\u00ac\2")
buf.write("\2\u0747\u074f\7\u00b3\2\2\u0748\u0749\5\u0126\u0094\2")
buf.write("\u0749\u074a\7\u00ac\2\2\u074a\u074b\7\u00b3\2\2\u074b")
buf.write("\u074f\3\2\2\2\u074c\u074f\5\u0122\u0092\2\u074d\u074f")
buf.write("\5\u0120\u0091\2\u074e\u073d\3\2\2\2\u074e\u073f\3\2\2")
buf.write("\2\u074e\u0742\3\2\2\2\u074e\u0743\3\2\2\2\u074e\u0744")
buf.write("\3\2\2\2\u074e\u0745\3\2\2\2\u074e\u0748\3\2\2\2\u074e")
buf.write("\u074c\3\2\2\2\u074e\u074d\3\2\2\2\u074f\u011f\3\2\2\2")
buf.write("\u0750\u0751\t\7\2\2\u0751\u0121\3\2\2\2\u0752\u0753\5")
buf.write("\u0116\u008c\2\u0753\u0754\7}\2\2\u0754\u0755\5\u0124")
buf.write("\u0093\2\u0755\u0756\7\u0082\2\2\u0756\u0123\3\2\2\2\u0757")
buf.write("\u0758\5\u0272\u013a\2\u0758\u0759\7|\2\2\u0759\u075a")
buf.write("\5\u0272\u013a\2\u075a\u0125\3\2\2\2\u075b\u075c\7\u00be")
buf.write("\2\2\u075c\u0127\3\2\2\2\u075d\u0760\5\u0272\u013a\2\u075e")
buf.write("\u0760\7\u00c2\2\2\u075f\u075d\3\2\2\2\u075f\u075e\3\2")
buf.write("\2\2\u0760\u0129\3\2\2\2\u0761\u0762\7\5\2\2\u0762\u0763")
buf.write("\5\u012c\u0097\2\u0763\u012b\3\2\2\2\u0764\u0765\5\u012e")
buf.write("\u0098\2\u0765\u012d\3\2\2\2\u0766\u0767\7\u00be\2\2\u0767")
buf.write("\u012f\3\2\2\2\u0768\u0769\b\u0099\1\2\u0769\u076c\5\22")
buf.write("\n\2\u076a\u076c\5\u0132\u009a\2\u076b\u0768\3\2\2\2\u076b")
buf.write("\u076a\3\2\2\2\u076c\u0773\3\2\2\2\u076d\u076e\f\4\2\2")
buf.write("\u076e\u0772\5\22\n\2\u076f\u0770\f\3\2\2\u0770\u0772")
buf.write("\5\u0132\u009a\2\u0771\u076d\3\2\2\2\u0771\u076f\3\2\2")
buf.write("\2\u0772\u0775\3\2\2\2\u0773\u0771\3\2\2\2\u0773\u0774")
buf.write("\3\2\2\2\u0774\u0131\3\2\2\2\u0775\u0773\3\2\2\2\u0776")
buf.write("\u0779\5\u0134\u009b\2\u0777\u0779\5\u0136\u009c\2\u0778")
buf.write("\u0776\3\2\2\2\u0778\u0777\3\2\2\2\u0779\u0133\3\2\2\2")
buf.write("\u077a\u077b\7\4\2\2\u077b\u0135\3\2\2\2\u077c\u077f\5")
buf.write("\u0138\u009d\2\u077d\u077f\5\u0260\u0131\2\u077e\u077c")
buf.write("\3\2\2\2\u077e\u077d\3\2\2\2\u077f\u0137\3\2\2\2\u0780")
buf.write("\u0781\5\u00dep\2\u0781\u0782\5\u013a\u009e\2\u0782\u0783")
buf.write("\5\u013c\u009f\2\u0783\u0139\3\2\2\2\u0784\u0785\7\u00be")
buf.write("\2\2\u0785\u013b\3\2\2\2\u0786\u0788\5\u00e2r\2\u0787")
buf.write("\u0789\5\u013e\u00a0\2\u0788\u0787\3\2\2\2\u0788\u0789")
buf.write("\3\2\2\2\u0789\u078a\3\2\2\2\u078a\u078b\5\u00eav\2\u078b")
buf.write("\u07a3\3\2\2\2\u078c\u078d\5\u00e2r\2\u078d\u078e\79\2")
buf.write("\2\u078e\u078f\7}\2\2\u078f\u0790\7\u00be\2\2\u0790\u0792")
buf.write("\7\u0082\2\2\u0791\u0793\5\u013e\u00a0\2\u0792\u0791\3")
buf.write("\2\2\2\u0792\u0793\3\2\2\2\u0793\u0794\3\2\2\2\u0794\u0795")
buf.write("\5\u00eav\2\u0795\u07a3\3\2\2\2\u0796\u0797\5\u00e2r\2")
buf.write("\u0797\u0798\79\2\2\u0798\u0799\7}\2\2\u0799\u079a\7\u00be")
buf.write("\2\2\u079a\u079b\7\u0082\2\2\u079b\u079c\5\16\b\2\u079c")
buf.write("\u079d\5\u00eav\2\u079d\u07a3\3\2\2\2\u079e\u079f\5\u00e2")
buf.write("r\2\u079f\u07a0\5\16\b\2\u07a0\u07a1\5\u00eav\2\u07a1")
buf.write("\u07a3\3\2\2\2\u07a2\u0786\3\2\2\2\u07a2\u078c\3\2\2\2")
buf.write("\u07a2\u0796\3\2\2\2\u07a2\u079e\3\2\2\2\u07a3\u013d\3")
buf.write("\2\2\2\u07a4\u07a6\5\u0140\u00a1\2\u07a5\u07a4\3\2\2\2")
buf.write("\u07a6\u07a7\3\2\2\2\u07a7\u07a5\3\2\2\2\u07a7\u07a8\3")
buf.write("\2\2\2\u07a8\u013f\3\2\2\2\u07a9\u07ac\5\22\n\2\u07aa")
buf.write("\u07ac\5\u0142\u00a2\2\u07ab\u07a9\3\2\2\2\u07ab\u07aa")
buf.write("\3\2\2\2\u07ac\u0141\3\2\2\2\u07ad\u07b3\5\u01b6\u00dc")
buf.write("\2\u07ae\u07b3\5\u0174\u00bb\2\u07af\u07b3\5\u0164\u00b3")
buf.write("\2\u07b0\u07b3\5\u0152\u00aa\2\u07b1\u07b3\5\u0144\u00a3")
buf.write("\2\u07b2\u07ad\3\2\2\2\u07b2\u07ae\3\2\2\2\u07b2\u07af")
buf.write("\3\2\2\2\u07b2\u07b0\3\2\2\2\u07b2\u07b1\3\2\2\2\u07b3")
buf.write("\u0143\3\2\2\2\u07b4\u07b5\5\u014c\u00a7\2\u07b5\u07b6")
buf.write("\5\u014a\u00a6\2\u07b6\u07bb\3\2\2\2\u07b7\u07b8\5\u0146")
buf.write("\u00a4\2\u07b8\u07b9\5\u014a\u00a6\2\u07b9\u07bb\3\2\2")
buf.write("\2\u07ba\u07b4\3\2\2\2\u07ba\u07b7\3\2\2\2\u07bb\u0145")
buf.write("\3\2\2\2\u07bc\u07bd\b\u00a4\1\2\u07bd\u07be\5\u014c\u00a7")
buf.write("\2\u07be\u07bf\5\u0148\u00a5\2\u07bf\u07c4\3\2\2\2\u07c0")
buf.write("\u07c1\f\3\2\2\u07c1\u07c3\5\u0242\u0122\2\u07c2\u07c0")
buf.write("\3\2\2\2\u07c3\u07c6\3\2\2\2\u07c4\u07c2\3\2\2\2\u07c4")
buf.write("\u07c5\3\2\2\2\u07c5\u0147\3\2\2\2\u07c6\u07c4\3\2\2\2")
buf.write("\u07c7\u07c8\7#\2\2\u07c8\u0149\3\2\2\2\u07c9\u07cd\7")
buf.write(">\2\2\u07ca\u07cb\7\16\2\2\u07cb\u07cd\7?\2\2\u07cc\u07c9")
buf.write("\3\2\2\2\u07cc\u07ca\3\2\2\2\u07cd\u014b\3\2\2\2\u07ce")
buf.write("\u07cf\b\u00a7\1\2\u07cf\u07d0\5\u014e\u00a8\2\u07d0\u07d5")
buf.write("\3\2\2\2\u07d1\u07d2\f\3\2\2\u07d2\u07d4\5\u0242\u0122")
buf.write("\2\u07d3\u07d1\3\2\2\2\u07d4\u07d7\3\2\2\2\u07d5\u07d3")
buf.write("\3\2\2\2\u07d5\u07d6\3\2\2\2\u07d6\u014d\3\2\2\2\u07d7")
buf.write("\u07d5\3\2\2\2\u07d8\u07d9\7?\2\2\u07d9\u07da\7}\2\2\u07da")
buf.write("\u07db\5\u0150\u00a9\2\u07db\u07dc\7\u0082\2\2\u07dc\u014f")
buf.write("\3\2\2\2\u07dd\u07de\5\u0272\u013a\2\u07de\u0151\3\2\2")
buf.write("\2\u07df\u07e0\7\u00be\2\2\u07e0\u07e1\7\u0083\2\2\u07e1")
buf.write("\u07e2\7A\2\2\u07e2\u07e3\7}\2\2\u07e3\u07e4\5\u0272\u013a")
buf.write("\2\u07e4\u07e5\7\u0082\2\2\u07e5\u07e6\5\u0154\u00ab\2")
buf.write("\u07e6\u07fe\3\2\2\2\u07e7\u07e8\7A\2\2\u07e8\u07e9\7")
buf.write("}\2\2\u07e9\u07ea\5\u0272\u013a\2\u07ea\u07eb\7\u0082")
buf.write("\2\2\u07eb\u07ec\5\u0154\u00ab\2\u07ec\u07fe\3\2\2\2\u07ed")
buf.write("\u07ee\7\u00be\2\2\u07ee\u07ef\7\u0083\2\2\u07ef\u07f0")
buf.write("\7B\2\2\u07f0\u07f1\7C\2\2\u07f1\u07f2\7}\2\2\u07f2\u07f3")
buf.write("\5\u0272\u013a\2\u07f3\u07f4\7\u0082\2\2\u07f4\u07f5\5")
buf.write("\u0154\u00ab\2\u07f5\u07fe\3\2\2\2\u07f6\u07f7\7B\2\2")
buf.write("\u07f7\u07f8\7C\2\2\u07f8\u07f9\7}\2\2\u07f9\u07fa\5\u0272")
buf.write("\u013a\2\u07fa\u07fb\7\u0082\2\2\u07fb\u07fc\5\u0154\u00ab")
buf.write("\2\u07fc\u07fe\3\2\2\2\u07fd\u07df\3\2\2\2\u07fd\u07e7")
buf.write("\3\2\2\2\u07fd\u07ed\3\2\2\2\u07fd\u07f6\3\2\2\2\u07fe")
buf.write("\u0153\3\2\2\2\u07ff\u0800\5\u0158\u00ad\2\u0800\u0801")
buf.write("\5\u0156\u00ac\2\u0801\u0804\3\2\2\2\u0802\u0804\5\u0156")
buf.write("\u00ac\2\u0803\u07ff\3\2\2\2\u0803\u0802\3\2\2\2\u0804")
buf.write("\u0155\3\2\2\2\u0805\u0807\7@\2\2\u0806\u0808\7\u00be")
buf.write("\2\2\u0807\u0806\3\2\2\2\u0807\u0808\3\2\2\2\u0808\u080f")
buf.write("\3\2\2\2\u0809\u080a\7\16\2\2\u080a\u080c\7B\2\2\u080b")
buf.write("\u080d\7\u00be\2\2\u080c\u080b\3\2\2\2\u080c\u080d\3\2")
buf.write("\2\2\u080d\u080f\3\2\2\2\u080e\u0805\3\2\2\2\u080e\u0809")
buf.write("\3\2\2\2\u080f\u0157\3\2\2\2\u0810\u0811\b\u00ad\1\2\u0811")
buf.write("\u0812\5\u015c\u00af\2\u0812\u0817\3\2\2\2\u0813\u0814")
buf.write("\f\3\2\2\u0814\u0816\5\u015a\u00ae\2\u0815\u0813\3\2\2")
buf.write("\2\u0816\u0819\3\2\2\2\u0817\u0815\3\2\2\2\u0817\u0818")
buf.write("\3\2\2\2\u0818\u0159\3\2\2\2\u0819\u0817\3\2\2\2\u081a")
buf.write("\u081d\5\u015c\u00af\2\u081b\u081d\5\u0186\u00c4\2\u081c")
buf.write("\u081a\3\2\2\2\u081c\u081b\3\2\2\2\u081d\u015b\3\2\2\2")
buf.write("\u081e\u081f\7C\2\2\u081f\u0825\5\u015e\u00b0\2\u0820")
buf.write("\u0821\7C\2\2\u0821\u0822\5\u015e\u00b0\2\u0822\u0823")
buf.write("\7\u00be\2\2\u0823\u0825\3\2\2\2\u0824\u081e\3\2\2\2\u0824")
buf.write("\u0820\3\2\2\2\u0825\u015d\3\2\2\2\u0826\u0827\7}\2\2")
buf.write("\u0827\u0828\5\u0160\u00b1\2\u0828\u0829\7\u0082\2\2\u0829")
buf.write("\u082c\3\2\2\2\u082a\u082c\7D\2\2\u082b\u0826\3\2\2\2")
buf.write("\u082b\u082a\3\2\2\2\u082c\u015f\3\2\2\2\u082d\u082f\5")
buf.write("\u0162\u00b2\2\u082e\u082d\3\2\2\2\u082f\u0830\3\2\2\2")
buf.write("\u0830\u082e\3\2\2\2\u0830\u0831\3\2\2\2\u0831\u0161\3")
buf.write("\2\2\2\u0832\u083d\5\u0272\u013a\2\u0833\u0834\5\u0272")
buf.write("\u013a\2\u0834\u0835\7\u0083\2\2\u0835\u083d\3\2\2\2\u0836")
buf.write("\u0837\7\u0083\2\2\u0837\u083d\5\u0272\u013a\2\u0838\u0839")
buf.write("\5\u0272\u013a\2\u0839\u083a\7\u0083\2\2\u083a\u083b\5")
buf.write("\u0272\u013a\2\u083b\u083d\3\2\2\2\u083c\u0832\3\2\2\2")
buf.write("\u083c\u0833\3\2\2\2\u083c\u0836\3\2\2\2\u083c\u0838\3")
buf.write("\2\2\2\u083d\u0163\3\2\2\2\u083e\u083f\5\u0166\u00b4\2")
buf.write("\u083f\u0843\5\u0168\u00b5\2\u0840\u0842\5\u016a\u00b6")
buf.write("\2\u0841\u0840\3\2\2\2\u0842\u0845\3\2\2\2\u0843\u0841")
buf.write("\3\2\2\2\u0843\u0844\3\2\2\2\u0844\u0847\3\2\2\2\u0845")
buf.write("\u0843\3\2\2\2\u0846\u0848\5\u016e\u00b8\2\u0847\u0846")
buf.write("\3\2\2\2\u0847\u0848\3\2\2\2\u0848\u0849\3\2\2\2\u0849")
buf.write("\u084a\5\u0172\u00ba\2\u084a\u0165\3\2\2\2\u084b\u084c")
buf.write("\7\65\2\2\u084c\u084d\7}\2\2\u084d\u084e\5\u0272\u013a")
buf.write("\2\u084e\u084f\7\u0082\2\2\u084f\u0850\7\66\2\2\u0850")
buf.write("\u0167\3\2\2\2\u0851\u0853\5\u0186\u00c4\2\u0852\u0851")
buf.write("\3\2\2\2\u0853\u0856\3\2\2\2\u0854\u0852\3\2\2\2\u0854")
buf.write("\u0855\3\2\2\2\u0855\u0169\3\2\2\2\u0856\u0854\3\2\2\2")
buf.write("\u0857\u0858\5\u016c\u00b7\2\u0858\u0859\5\u0168\u00b5")
buf.write("\2\u0859\u016b\3\2\2\2\u085a\u085b\7:\2\2\u085b\u085c")
buf.write("\7}\2\2\u085c\u085d\5\u0272\u013a\2\u085d\u085e\7\u0082")
buf.write("\2\2\u085e\u085f\7\66\2\2\u085f\u0868\3\2\2\2\u0860\u0861")
buf.write("\7\67\2\2\u0861\u0862\7\65\2\2\u0862\u0863\7}\2\2\u0863")
buf.write("\u0864\5\u0272\u013a\2\u0864\u0865\7\u0082\2\2\u0865\u0866")
buf.write("\7\66\2\2\u0866\u0868\3\2\2\2\u0867\u085a\3\2\2\2\u0867")
buf.write("\u0860\3\2\2\2\u0868\u016d\3\2\2\2\u0869\u086a\5\u0170")
buf.write("\u00b9\2\u086a\u086b\5\u0168\u00b5\2\u086b\u016f\3\2\2")
buf.write("\2\u086c\u086d\7\67\2\2\u086d\u0171\3\2\2\2\u086e\u0872")
buf.write("\78\2\2\u086f\u0870\7\16\2\2\u0870\u0872\7\65\2\2\u0871")
buf.write("\u086e\3\2\2\2\u0871\u086f\3\2\2\2\u0872\u0173\3\2\2\2")
buf.write("\u0873\u0876\5\u017e\u00c0\2\u0874\u0876\5\u0176\u00bc")
buf.write("\2\u0875\u0873\3\2\2\2\u0875\u0874\3\2\2\2\u0876\u0175")
buf.write("\3\2\2\2\u0877\u0879\5\u017c\u00bf\2\u0878\u0877\3\2\2")
buf.write("\2\u0878\u0879\3\2\2\2\u0879\u087a\3\2\2\2\u087a\u087c")
buf.write("\7;\2\2\u087b\u087d\5\u01ae\u00d8\2\u087c\u087b\3\2\2")
buf.write("\2\u087c\u087d\3\2\2\2\u087d\u0881\3\2\2\2\u087e\u0880")
buf.write("\5\u0186\u00c4\2\u087f\u087e\3\2\2\2\u0880\u0883\3\2\2")
buf.write("\2\u0881\u087f\3\2\2\2\u0881\u0882\3\2\2\2\u0882\u0884")
buf.write("\3\2\2\2\u0883\u0881\3\2\2\2\u0884\u0885\5\u0178\u00bd")
buf.write("\2\u0885\u0177\3\2\2\2\u0886\u0888\7H\2\2\u0887\u0889")
buf.write("\5\u017a\u00be\2\u0888\u0887\3\2\2\2\u0888\u0889\3\2\2")
buf.write("\2\u0889\u0890\3\2\2\2\u088a\u088b\7\16\2\2\u088b\u088d")
buf.write("\7;\2\2\u088c\u088e\5\u017a\u00be\2\u088d\u088c\3\2\2")
buf.write("\2\u088d\u088e\3\2\2\2\u088e\u0890\3\2\2\2\u088f\u0886")
buf.write("\3\2\2\2\u088f\u088a\3\2\2\2\u0890\u0179\3\2\2\2\u0891")
buf.write("\u0892\5\u012e\u0098\2\u0892\u017b\3\2\2\2\u0893\u0894")
buf.write("\7\u00be\2\2\u0894\u0895\7\u0083\2\2\u0895\u017d\3\2\2")
buf.write("\2\u0896\u0897\7;\2\2\u0897\u0898\5\u0180\u00c1\2\u0898")
buf.write("\u089c\5\u01ae\u00d8\2\u0899\u089b\5\u0186\u00c4\2\u089a")
buf.write("\u0899\3\2\2\2\u089b\u089e\3\2\2\2\u089c\u089a\3\2\2\2")
buf.write("\u089c\u089d\3\2\2\2\u089d\u089f\3\2\2\2\u089e\u089c\3")
buf.write("\2\2\2\u089f\u08a0\5\u0182\u00c2\2\u08a0\u08a1\5\u0184")
buf.write("\u00c3\2\u08a1\u017f\3\2\2\2\u08a2\u08a3\7\u00bc\2\2\u08a3")
buf.write("\u0181\3\2\2\2\u08a4\u08a5\7\u00bc\2\2\u08a5\u0183\3\2")
buf.write("\2\2\u08a6\u08a7\5\u01b6\u00dc\2\u08a7\u0185\3\2\2\2\u08a8")
buf.write("\u08ae\5\u0142\u00a2\2\u08a9\u08ae\5\62\32\2\u08aa\u08ae")
buf.write("\5\u018a\u00c6\2\u08ab\u08ae\5@!\2\u08ac\u08ae\5\u0188")
buf.write("\u00c5\2\u08ad\u08a8\3\2\2\2\u08ad\u08a9\3\2\2\2\u08ad")
buf.write("\u08aa\3\2\2\2\u08ad\u08ab\3\2\2\2\u08ad\u08ac\3\2\2\2")
buf.write("\u08ae\u0187\3\2\2\2\u08af\u08b0\7;\2\2\u08b0\u08b1\5")
buf.write("\u023e\u0120\2\u08b1\u08b2\5\u01ae\u00d8\2\u08b2\u0189")
buf.write("\3\2\2\2\u08b3\u08b4\7\62\2\2\u08b4\u08bb\5\u018c\u00c7")
buf.write("\2\u08b5\u08b7\7|\2\2\u08b6\u08b5\3\2\2\2\u08b6\u08b7")
buf.write("\3\2\2\2\u08b7\u08b8\3\2\2\2\u08b8\u08ba\5\u018c\u00c7")
buf.write("\2\u08b9\u08b6\3\2\2\2\u08ba\u08bd\3\2\2\2\u08bb\u08b9")
buf.write("\3\2\2\2\u08bb\u08bc\3\2\2\2\u08bc\u018b\3\2\2\2\u08bd")
buf.write("\u08bb\3\2\2\2\u08be\u08bf\5\u018e\u00c8\2\u08bf\u08c0")
buf.write("\5\u0190\u00c9\2\u08c0\u018d\3\2\2\2\u08c1\u08c6\5\u0194")
buf.write("\u00cb\2\u08c2\u08c3\7|\2\2\u08c3\u08c5\5\u0194\u00cb")
buf.write("\2\u08c4\u08c2\3\2\2\2\u08c5\u08c8\3\2\2\2\u08c6\u08c4")
buf.write("\3\2\2\2\u08c6\u08c7\3\2\2\2\u08c7\u08c9\3\2\2\2\u08c8")
buf.write("\u08c6\3\2\2\2\u08c9\u08ca\7\u0087\2\2\u08ca\u018f\3\2")
buf.write("\2\2\u08cb\u08d0\5\u0192\u00ca\2\u08cc\u08cd\7|\2\2\u08cd")
buf.write("\u08cf\5\u0192\u00ca\2\u08ce\u08cc\3\2\2\2\u08cf\u08d2")
buf.write("\3\2\2\2\u08d0\u08ce\3\2\2\2\u08d0\u08d1\3\2\2\2\u08d1")
buf.write("\u08d3\3\2\2\2\u08d2\u08d0\3\2\2\2\u08d3\u08d4\7\u0087")
buf.write("\2\2\u08d4\u0191\3\2\2\2\u08d5\u08df\5\u011e\u0090\2\u08d6")
buf.write("\u08d7\5\u011e\u0090\2\u08d7\u08d8\7\u00c2\2\2\u08d8\u08d9")
buf.write("\5\u011e\u0090\2\u08d9\u08df\3\2\2\2\u08da\u08db\5\u0126")
buf.write("\u0094\2\u08db\u08dc\7\u00c2\2\2\u08dc\u08dd\5\u011e\u0090")
buf.write("\2\u08dd\u08df\3\2\2\2\u08de\u08d5\3\2\2\2\u08de\u08d6")
buf.write("\3\2\2\2\u08de\u08da\3\2\2\2\u08df\u0193\3\2\2\2\u08e0")
buf.write("\u08e3\5\u0196\u00cc\2\u08e1\u08e3\5\u01a0\u00d1\2\u08e2")
buf.write("\u08e0\3\2\2\2\u08e2\u08e1\3\2\2\2\u08e3\u0195\3\2\2\2")
buf.write("\u08e4\u08e6\5\u01b2\u00da\2\u08e5\u08e7\5\u0198\u00cd")
buf.write("\2\u08e6\u08e5\3\2\2\2\u08e6\u08e7\3\2\2\2\u08e7\u08e9")
buf.write("\3\2\2\2\u08e8\u08ea\5\u019e\u00d0\2\u08e9\u08e8\3\2\2")
buf.write("\2\u08e9\u08ea\3\2\2\2\u08ea\u0197\3\2\2\2\u08eb\u08ec")
buf.write("\7}\2\2\u08ec\u08ed\5\u019a\u00ce\2\u08ed\u08ee\7\u0082")
buf.write("\2\2\u08ee\u0199\3\2\2\2\u08ef\u08f1\5\u019c\u00cf\2\u08f0")
buf.write("\u08ef\3\2\2\2\u08f1\u08f2\3\2\2\2\u08f2\u08f0\3\2\2\2")
buf.write("\u08f2\u08f3\3\2\2\2\u08f3\u019b\3\2\2\2\u08f4\u08f5\5")
buf.write("\u0272\u013a\2\u08f5\u019d\3\2\2\2\u08f6\u08f8\7}\2\2")
buf.write("\u08f7\u08f9\5\u0272\u013a\2\u08f8\u08f7\3\2\2\2\u08f8")
buf.write("\u08f9\3\2\2\2\u08f9\u08fa\3\2\2\2\u08fa\u08fb\5\u02aa")
buf.write("\u0156\2\u08fb\u08fc\7\u0082\2\2\u08fc\u019f\3\2\2\2\u08fd")
buf.write("\u08fe\7}\2\2\u08fe\u08ff\5\u01a2\u00d2\2\u08ff\u0900")
buf.write("\7|\2\2\u0900\u0901\5\u01ac\u00d7\2\u0901\u0902\7\u0084")
buf.write("\2\2\u0902\u0903\5\u0272\u013a\2\u0903\u0904\7|\2\2\u0904")
buf.write("\u0905\5\u0272\u013a\2\u0905\u0906\7\u0082\2\2\u0906\u0914")
buf.write("\3\2\2\2\u0907\u0908\7}\2\2\u0908\u0909\5\u01a2\u00d2")
buf.write("\2\u0909\u090a\7|\2\2\u090a\u090b\5\u01ac\u00d7\2\u090b")
buf.write("\u090c\7\u0084\2\2\u090c\u090d\5\u0272\u013a\2\u090d\u090e")
buf.write("\7|\2\2\u090e\u090f\5\u0272\u013a\2\u090f\u0910\7|\2\2")
buf.write("\u0910\u0911\5\u0272\u013a\2\u0911\u0912\7\u0082\2\2\u0912")
buf.write("\u0914\3\2\2\2\u0913\u08fd\3\2\2\2\u0913\u0907\3\2\2\2")
buf.write("\u0914\u01a1\3\2\2\2\u0915\u0917\5\u01a4\u00d3\2\u0916")
buf.write("\u0915\3\2\2\2\u0917\u0918\3\2\2\2\u0918\u0916\3\2\2\2")
buf.write("\u0918\u0919\3\2\2\2\u0919\u01a3\3\2\2\2\u091a\u091e\5")
buf.write("\u01aa\u00d6\2\u091b\u091e\5\u01a0\u00d1\2\u091c\u091e")
buf.write("\5\u01a6\u00d4\2\u091d\u091a\3\2\2\2\u091d\u091b\3\2\2")
buf.write("\2\u091d\u091c\3\2\2\2\u091e\u01a5\3\2\2\2\u091f\u0920")
buf.write("\b\u00d4\1\2\u0920\u0921\5\u01b2\u00da\2\u0921\u0922\5")
buf.write("\u01a8\u00d5\2\u0922\u0927\3\2\2\2\u0923\u0924\f\3\2\2")
buf.write("\u0924\u0926\5\u01a8\u00d5\2\u0925\u0923\3\2\2\2\u0926")
buf.write("\u0929\3\2\2\2\u0927\u0925\3\2\2\2\u0927\u0928\3\2\2\2")
buf.write("\u0928\u01a7\3\2\2\2\u0929\u0927\3\2\2\2\u092a\u092b\7")
buf.write("}\2\2\u092b\u092c\5\u02a6\u0154\2\u092c\u092d\7\u0082")
buf.write("\2\2\u092d\u092e\7~\2\2\u092e\u092f\7\u00be\2\2\u092f")
buf.write("\u0933\3\2\2\2\u0930\u0931\7~\2\2\u0931\u0933\7\u00be")
buf.write("\2\2\u0932\u092a\3\2\2\2\u0932\u0930\3\2\2\2\u0933\u01a9")
buf.write("\3\2\2\2\u0934\u0935\5\u01b2\u00da\2\u0935\u0936\7}\2")
buf.write("\2\u0936\u0937\5\u02a6\u0154\2\u0937\u0938\7\u0082\2\2")
buf.write("\u0938\u093f\3\2\2\2\u0939\u093a\5\u01a6\u00d4\2\u093a")
buf.write("\u093b\7}\2\2\u093b\u093c\5\u02a6\u0154\2\u093c\u093d")
buf.write("\7\u0082\2\2\u093d\u093f\3\2\2\2\u093e\u0934\3\2\2\2\u093e")
buf.write("\u0939\3\2\2\2\u093f\u01ab\3\2\2\2\u0940\u0941\7\u00be")
buf.write("\2\2\u0941\u01ad\3\2\2\2\u0942\u0944\7|\2\2\u0943\u0942")
buf.write("\3\2\2\2\u0943\u0944\3\2\2\2\u0944\u0945\3\2\2\2\u0945")
buf.write("\u0946\5\u01b0\u00d9\2\u0946\u01af\3\2\2\2\u0947\u0948")
buf.write("\5\u01b2\u00da\2\u0948\u0949\7\u0084\2\2\u0949\u094a\5")
buf.write("\u0272\u013a\2\u094a\u094b\7|\2\2\u094b\u094d\5\u0272")
buf.write("\u013a\2\u094c\u094e\5\u01b4\u00db\2\u094d\u094c\3\2\2")
buf.write("\2\u094d\u094e\3\2\2\2\u094e\u0955\3\2\2\2\u094f\u0950")
buf.write("\7\177\2\2\u0950\u0951\7}\2\2\u0951\u0952\5\u0272\u013a")
buf.write("\2\u0952\u0953\7\u0082\2\2\u0953\u0955\3\2\2\2\u0954\u0947")
buf.write("\3\2\2\2\u0954\u094f\3\2\2\2\u0955\u01b1\3\2\2\2\u0956")
buf.write("\u0957\7\u00be\2\2\u0957\u01b3\3\2\2\2\u0958\u0959\7|")
buf.write("\2\2\u0959\u095a\5\u0272\u013a\2\u095a\u01b5\3\2\2\2\u095b")
buf.write("\u0979\5\u023c\u011f\2\u095c\u0979\5\u0242\u0122\2\u095d")
buf.write("\u0979\5\u024a\u0126\2\u095e\u0979\5\u024c\u0127\2\u095f")
buf.write("\u0979\5\u0234\u011b\2\u0960\u0979\5\u0226\u0114\2\u0961")
buf.write("\u0979\5\u0224\u0113\2\u0962\u0979\5\u0222\u0112\2\u0963")
buf.write("\u0979\5\u021c\u010f\2\u0964\u0979\5\u021e\u0110\2\u0965")
buf.write("\u0979\5\u0218\u010d\2\u0966\u0979\5\u02b8\u015d\2\u0967")
buf.write("\u0979\5\u0212\u010a\2\u0968\u0979\5\u020c\u0107\2\u0969")
buf.write("\u0979\5\u020a\u0106\2\u096a\u0979\5\u0200\u0101\2\u096b")
buf.write("\u0979\5\u01ea\u00f6\2\u096c\u0979\5\u01e6\u00f4\2\u096d")
buf.write("\u0979\5\u01e8\u00f5\2\u096e\u0979\5\u01de\u00f0\2\u096f")
buf.write("\u0979\5\u01d8\u00ed\2\u0970\u0979\5\u01da\u00ee\2\u0971")
buf.write("\u0979\5\u01ce\u00e8\2\u0972\u0979\5\u01cc\u00e7\2\u0973")
buf.write("\u0979\5\u01c8\u00e5\2\u0974\u0979\5\u01c6\u00e4\2\u0975")
buf.write("\u0979\5\u01be\u00e0\2\u0976\u0979\5\u01ba\u00de\2\u0977")
buf.write("\u0979\5\u01b8\u00dd\2\u0978\u095b\3\2\2\2\u0978\u095c")
buf.write("\3\2\2\2\u0978\u095d\3\2\2\2\u0978\u095e\3\2\2\2\u0978")
buf.write("\u095f\3\2\2\2\u0978\u0960\3\2\2\2\u0978\u0961\3\2\2\2")
buf.write("\u0978\u0962\3\2\2\2\u0978\u0963\3\2\2\2\u0978\u0964\3")
buf.write("\2\2\2\u0978\u0965\3\2\2\2\u0978\u0966\3\2\2\2\u0978\u0967")
buf.write("\3\2\2\2\u0978\u0968\3\2\2\2\u0978\u0969\3\2\2\2\u0978")
buf.write("\u096a\3\2\2\2\u0978\u096b\3\2\2\2\u0978\u096c\3\2\2\2")
buf.write("\u0978\u096d\3\2\2\2\u0978\u096e\3\2\2\2\u0978\u096f\3")
buf.write("\2\2\2\u0978\u0970\3\2\2\2\u0978\u0971\3\2\2\2\u0978\u0972")
buf.write("\3\2\2\2\u0978\u0973\3\2\2\2\u0978\u0974\3\2\2\2\u0978")
buf.write("\u0975\3\2\2\2\u0978\u0976\3\2\2\2\u0978\u0977\3\2\2\2")
buf.write("\u0979\u01b7\3\2\2\2\u097a\u097b\7?\2\2\u097b\u097c\7")
buf.write("}\2\2\u097c\u097d\5\u0150\u00a9\2\u097d\u097e\7\u0082")
buf.write("\2\2\u097e\u097f\5\u0242\u0122\2\u097f\u01b9\3\2\2\2\u0980")
buf.write("\u0981\7\u00be\2\2\u0981\u0982\7\33\2\2\u0982\u098d\5")
buf.write("\u01bc\u00df\2\u0983\u0985\7\u00be\2\2\u0984\u0986\5\u0244")
buf.write("\u0123\2\u0985\u0984\3\2\2\2\u0985\u0986\3\2\2\2\u0986")
buf.write("\u0987\3\2\2\2\u0987\u0988\7~\2\2\u0988\u0989\5\u02a0")
buf.write("\u0151\2\u0989\u098a\7\33\2\2\u098a\u098b\5\u01bc\u00df")
buf.write("\2\u098b\u098d\3\2\2\2\u098c\u0980\3\2\2\2\u098c\u0983")
buf.write("\3\2\2\2\u098d\u01bb\3\2\2\2\u098e\u098f\5\u0272\u013a")
buf.write("\2\u098f\u01bd\3\2\2\2\u0990\u0991\7\u00b6\2\2\u0991\u0992")
buf.write("\7}\2\2\u0992\u0993\5\u01c0\u00e1\2\u0993\u0994\7\u0082")
buf.write("\2\2\u0994\u01bf\3\2\2\2\u0995\u099a\5\u01c2\u00e2\2\u0996")
buf.write("\u0997\7|\2\2\u0997\u0999\5\u01c2\u00e2\2\u0998\u0996")
buf.write("\3\2\2\2\u0999\u099c\3\2\2\2\u099a\u0998\3\2\2\2\u099a")
buf.write("\u099b\3\2\2\2\u099b\u01c1\3\2\2\2\u099c\u099a\3\2\2\2")
buf.write("\u099d\u09a0\7\u00be\2\2\u099e\u09a0\5\u01c4\u00e3\2\u099f")
buf.write("\u099d\3\2\2\2\u099f\u099e\3\2\2\2\u09a0\u01c3\3\2\2\2")
buf.write("\u09a1\u09a2\b\u00e3\1\2\u09a2\u09a4\7\u00be\2\2\u09a3")
buf.write("\u09a5\5\u0244\u0123\2\u09a4\u09a3\3\2\2\2\u09a4\u09a5")
buf.write("\3\2\2\2\u09a5\u09a6\3\2\2\2\u09a6\u09a7\7~\2\2\u09a7")
buf.write("\u09a8\7\u00be\2\2\u09a8\u09ad\3\2\2\2\u09a9\u09aa\f\3")
buf.write("\2\2\u09aa\u09ac\5\u01a8\u00d5\2\u09ab\u09a9\3\2\2\2\u09ac")
buf.write("\u09af\3\2\2\2\u09ad\u09ab\3\2\2\2\u09ad\u09ae\3\2\2\2")
buf.write("\u09ae\u01c5\3\2\2\2\u09af\u09ad\3\2\2\2\u09b0\u09b2\7")
buf.write("\u00bf\2\2\u09b1\u09b3\5\u017a\u00be\2\u09b2\u09b1\3\2")
buf.write("\2\2\u09b2\u09b3\3\2\2\2\u09b3\u01c7\3\2\2\2\u09b4\u09b5")
buf.write("\7\u00b5\2\2\u09b5\u09b6\7}\2\2\u09b6\u09b7\5\u01ca\u00e6")
buf.write("\2\u09b7\u09b8\7|\2\2\u09b8\u09b9\7\u0081\2\2\u09b9\u09ba")
buf.write("\7\u0084\2\2\u09ba\u09bb\5\u0196\u00cc\2\u09bb\u09bc\7")
buf.write("\u0082\2\2\u09bc\u09c3\3\2\2\2\u09bd\u09be\7\u00b5\2\2")
buf.write("\u09be\u09bf\7}\2\2\u09bf\u09c0\5\u01ca\u00e6\2\u09c0")
buf.write("\u09c1\7\u0082\2\2\u09c1\u09c3\3\2\2\2\u09c2\u09b4\3\2")
buf.write("\2\2\u09c2\u09bd\3\2\2\2\u09c3\u01c9\3\2\2\2\u09c4\u09c9")
buf.write("\5\u01d4\u00eb\2\u09c5\u09c6\7|\2\2\u09c6\u09c8\5\u01d4")
buf.write("\u00eb\2\u09c7\u09c5\3\2\2\2\u09c8\u09cb\3\2\2\2\u09c9")
buf.write("\u09c7\3\2\2\2\u09c9\u09ca\3\2\2\2\u09ca\u01cb\3\2\2\2")
buf.write("\u09cb\u09c9\3\2\2\2\u09cc\u09ce\7\u00b7\2\2\u09cd\u09cf")
buf.write("\5\u017a\u00be\2\u09ce\u09cd\3\2\2\2\u09ce\u09cf\3\2\2")
buf.write("\2\u09cf\u01cd\3\2\2\2\u09d0\u09d1\7\u0080\2\2\u09d1\u09d2")
buf.write("\7}\2\2\u09d2\u09d3\5\u01d0\u00e9\2\u09d3\u09d4\7|\2\2")
buf.write("\u09d4\u09d5\7\u0081\2\2\u09d5\u09d6\7\u0084\2\2\u09d6")
buf.write("\u09d7\5\u0196\u00cc\2\u09d7\u09d8\7\u0082\2\2\u09d8\u09df")
buf.write("\3\2\2\2\u09d9\u09da\7\u0080\2\2\u09da\u09db\7}\2\2\u09db")
buf.write("\u09dc\5\u01d0\u00e9\2\u09dc\u09dd\7\u0082\2\2\u09dd\u09df")
buf.write("\3\2\2\2\u09de\u09d0\3\2\2\2\u09de\u09d9\3\2\2\2\u09df")
buf.write("\u01cf\3\2\2\2\u09e0\u09e5\5\u01d2\u00ea\2\u09e1\u09e2")
buf.write("\7|\2\2\u09e2\u09e4\5\u01d2\u00ea\2\u09e3\u09e1\3\2\2")
buf.write("\2\u09e4\u09e7\3\2\2\2\u09e5\u09e3\3\2\2\2\u09e5\u09e6")
buf.write("\3\2\2\2\u09e6\u01d1\3\2\2\2\u09e7\u09e5\3\2\2\2\u09e8")
buf.write("\u09ed\5\u01d4\u00eb\2\u09e9\u09ea\5\u01d4\u00eb\2\u09ea")
buf.write("\u09eb\5\u01d6\u00ec\2\u09eb\u09ed\3\2\2\2\u09ec\u09e8")
buf.write("\3\2\2\2\u09ec\u09e9\3\2\2\2\u09ed\u01d3\3\2\2\2\u09ee")
buf.write("\u09ef\b\u00eb\1\2\u09ef\u09f0\5\u01b2\u00da\2\u09f0\u09f5")
buf.write("\3\2\2\2\u09f1\u09f2\f\3\2\2\u09f2\u09f4\5\u01a8\u00d5")
buf.write("\2\u09f3\u09f1\3\2\2\2\u09f4\u09f7\3\2\2\2\u09f5\u09f3")
buf.write("\3\2\2\2\u09f5\u09f6\3\2\2\2\u09f6\u01d5\3\2\2\2\u09f7")
buf.write("\u09f5\3\2\2\2\u09f8\u09f9\7}\2\2\u09f9\u09fa\5\u02a6")
buf.write("\u0154\2\u09fa\u09fb\7\u0082\2\2\u09fb\u01d7\3\2\2\2\u09fc")
buf.write("\u09fe\7F\2\2\u09fd\u09ff\t\b\2\2\u09fe\u09fd\3\2\2\2")
buf.write("\u09fe\u09ff\3\2\2\2\u09ff\u01d9\3\2\2\2\u0a00\u0a01\7")
buf.write("J\2\2\u0a01\u0a02\7}\2\2\u0a02\u0a03\5\u01dc\u00ef\2\u0a03")
buf.write("\u0a05\7\u0082\2\2\u0a04\u0a06\5\u0202\u0102\2\u0a05\u0a04")
buf.write("\3\2\2\2\u0a05\u0a06\3\2\2\2\u0a06\u01db\3\2\2\2\u0a07")
buf.write("\u0a08\b\u00ef\1\2\u0a08\u0a09\5\u024e\u0128\2\u0a09\u0a0a")
buf.write("\7{\2\2\u0a0a\u0a0b\7|\2\2\u0a0b\u0a16\3\2\2\2\u0a0c\u0a0d")
buf.write("\5\u024e\u0128\2\u0a0d\u0a0e\7|\2\2\u0a0e\u0a0f\5\u0208")
buf.write("\u0105\2\u0a0f\u0a16\3\2\2\2\u0a10\u0a11\5\u024e\u0128")
buf.write("\2\u0a11\u0a12\7|\2\2\u0a12\u0a13\5\u01fe\u0100\2\u0a13")
buf.write("\u0a16\3\2\2\2\u0a14\u0a16\5\u01fe\u0100\2\u0a15\u0a07")
buf.write("\3\2\2\2\u0a15\u0a0c\3\2\2\2\u0a15\u0a10\3\2\2\2\u0a15")
buf.write("\u0a14\3\2\2\2\u0a16\u0a1c\3\2\2\2\u0a17\u0a18\f\3\2\2")
buf.write("\u0a18\u0a19\7|\2\2\u0a19\u0a1b\5\u01fe\u0100\2\u0a1a")
buf.write("\u0a17\3\2\2\2\u0a1b\u0a1e\3\2\2\2\u0a1c\u0a1a\3\2\2\2")
buf.write("\u0a1c\u0a1d\3\2\2\2\u0a1d\u01dd\3\2\2\2\u0a1e\u0a1c\3")
buf.write("\2\2\2\u0a1f\u0a20\7\u00be\2\2\u0a20\u0a21\5\u01e0\u00f1")
buf.write("\2\u0a21\u01df\3\2\2\2\u0a22\u0a24\7}\2\2\u0a23\u0a25")
buf.write("\5\u01e2\u00f2\2\u0a24\u0a23\3\2\2\2\u0a24\u0a25\3\2\2")
buf.write("\2\u0a25\u0a26\3\2\2\2\u0a26\u0a27\7\u0082\2\2\u0a27\u0a28")
buf.write("\7\u0084\2\2\u0a28\u0a29\5\u0272\u013a\2\u0a29\u01e1\3")
buf.write("\2\2\2\u0a2a\u0a2f\5\u01e4\u00f3\2\u0a2b\u0a2c\7|\2\2")
buf.write("\u0a2c\u0a2e\5\u01e4\u00f3\2\u0a2d\u0a2b\3\2\2\2\u0a2e")
buf.write("\u0a31\3\2\2\2\u0a2f\u0a2d\3\2\2\2\u0a2f\u0a30\3\2\2\2")
buf.write("\u0a30\u01e3\3\2\2\2\u0a31\u0a2f\3\2\2\2\u0a32\u0a33\7")
buf.write("\u00be\2\2\u0a33\u01e5\3\2\2\2\u0a34\u0a36\7]\2\2\u0a35")
buf.write("\u0a37\5\u0272\u013a\2\u0a36\u0a35\3\2\2\2\u0a36\u0a37")
buf.write("\3\2\2\2\u0a37\u01e7\3\2\2\2\u0a38\u0a39\7t\2\2\u0a39")
buf.write("\u0a40\5\u024e\u0128\2\u0a3a\u0a3b\7t\2\2\u0a3b\u0a3c")
buf.write("\7}\2\2\u0a3c\u0a3d\5\u0250\u0129\2\u0a3d\u0a3e\7\u0082")
buf.write("\2\2\u0a3e\u0a40\3\2\2\2\u0a3f\u0a38\3\2\2\2\u0a3f\u0a3a")
buf.write("\3\2\2\2\u0a40\u01e9\3\2\2\2\u0a41\u0a42\7K\2\2\u0a42")
buf.write("\u0a44\5\u01f8\u00fd\2\u0a43\u0a45\5\u01f2\u00fa\2\u0a44")
buf.write("\u0a43\3\2\2\2\u0a44\u0a45\3\2\2\2\u0a45\u0a4c\3\2\2\2")
buf.write("\u0a46\u0a47\7K\2\2\u0a47\u0a49\5\u01ee\u00f8\2\u0a48")
buf.write("\u0a4a\5\u01ec\u00f7\2\u0a49\u0a48\3\2\2\2\u0a49\u0a4a")
buf.write("\3\2\2\2\u0a4a\u0a4c\3\2\2\2\u0a4b\u0a41\3\2\2\2\u0a4b")
buf.write("\u0a46\3\2\2\2\u0a4c\u01eb\3\2\2\2\u0a4d\u0a4e\7|\2\2")
buf.write("\u0a4e\u0a4f\5\u01f2\u00fa\2\u0a4f\u01ed\3\2\2\2\u0a50")
buf.write("\u0a62\5\u023e\u0120\2\u0a51\u0a62\7\u00c2\2\2\u0a52\u0a62")
buf.write("\5\u0230\u0119\2\u0a53\u0a54\5\u0230\u0119\2\u0a54\u0a55")
buf.write("\7\u0087\2\2\u0a55\u0a56\7\u00ba\2\2\u0a56\u0a57\7\u0087")
buf.write("\2\2\u0a57\u0a58\7\u00bb\2\2\u0a58\u0a59\5\u022e\u0118")
buf.write("\2\u0a59\u0a62\3\2\2\2\u0a5a\u0a5b\5\u01f0\u00f9\2\u0a5b")
buf.write("\u0a5c\7\u0087\2\2\u0a5c\u0a5d\7\u00ba\2\2\u0a5d\u0a5e")
buf.write("\7\u0087\2\2\u0a5e\u0a5f\7\u00bb\2\2\u0a5f\u0a60\5\u022e")
buf.write("\u0118\2\u0a60\u0a62\3\2\2\2\u0a61\u0a50\3\2\2\2\u0a61")
buf.write("\u0a51\3\2\2\2\u0a61\u0a52\3\2\2\2\u0a61\u0a53\3\2\2\2")
buf.write("\u0a61\u0a5a\3\2\2\2\u0a62\u01ef\3\2\2\2\u0a63\u0a64\7")
buf.write("}\2\2\u0a64\u0a65\5\u0258\u012d\2\u0a65\u0a66\7\u0082")
buf.write("\2\2\u0a66\u01f1\3\2\2\2\u0a67\u0a6c\5\u01f4\u00fb\2\u0a68")
buf.write("\u0a69\7|\2\2\u0a69\u0a6b\5\u01f4\u00fb\2\u0a6a\u0a68")
buf.write("\3\2\2\2\u0a6b\u0a6e\3\2\2\2\u0a6c\u0a6a\3\2\2\2\u0a6c")
buf.write("\u0a6d\3\2\2\2\u0a6d\u01f3\3\2\2\2\u0a6e\u0a6c\3\2\2\2")
buf.write("\u0a6f\u0a72\5\u02a0\u0151\2\u0a70\u0a72\5\u01f6\u00fc")
buf.write("\2\u0a71\u0a6f\3\2\2\2\u0a71\u0a70\3\2\2\2\u0a72\u01f5")
buf.write("\3\2\2\2\u0a73\u0a74\7}\2\2\u0a74\u0a75\5\u01f2\u00fa")
buf.write("\2\u0a75\u0a76\7|\2\2\u0a76\u0a77\5\u01ac\u00d7\2\u0a77")
buf.write("\u0a78\7\u0084\2\2\u0a78\u0a79\5\u0272\u013a\2\u0a79\u0a7a")
buf.write("\7|\2\2\u0a7a\u0a7c\5\u0272\u013a\2\u0a7b\u0a7d\5\u01b4")
buf.write("\u00db\2\u0a7c\u0a7b\3\2\2\2\u0a7c\u0a7d\3\2\2\2\u0a7d")
buf.write("\u0a7e\3\2\2\2\u0a7e\u0a7f\7\u0082\2\2\u0a7f\u01f7\3\2")
buf.write("\2\2\u0a80\u0a86\5\u01fa\u00fe\2\u0a81\u0a82\7}\2\2\u0a82")
buf.write("\u0a83\5\u01fc\u00ff\2\u0a83\u0a84\7\u0082\2\2\u0a84\u0a86")
buf.write("\3\2\2\2\u0a85\u0a80\3\2\2\2\u0a85\u0a81\3\2\2\2\u0a86")
buf.write("\u01f9\3\2\2\2\u0a87\u0a88\7}\2\2\u0a88\u0a89\5\u0258")
buf.write("\u012d\2\u0a89\u0a8a\7\u0082\2\2\u0a8a\u0a8f\3\2\2\2\u0a8b")
buf.write("\u0a8c\7}\2\2\u0a8c\u0a8d\7\u00c2\2\2\u0a8d\u0a8f\7\u0082")
buf.write("\2\2\u0a8e\u0a87\3\2\2\2\u0a8e\u0a8b\3\2\2\2\u0a8f\u01fb")
buf.write("\3\2\2\2\u0a90\u0a91\b\u00ff\1\2\u0a91\u0a92\5\u024e\u0128")
buf.write("\2\u0a92\u0a93\7|\2\2\u0a93\u0a94\5\u01fe\u0100\2\u0a94")
buf.write("\u0a9b\3\2\2\2\u0a95\u0a96\5\u024e\u0128\2\u0a96\u0a97")
buf.write("\7|\2\2\u0a97\u0a98\5\u0208\u0105\2\u0a98\u0a9b\3\2\2")
buf.write("\2\u0a99\u0a9b\5\u01fe\u0100\2\u0a9a\u0a90\3\2\2\2\u0a9a")
buf.write("\u0a95\3\2\2\2\u0a9a\u0a99\3\2\2\2\u0a9b\u0aa1\3\2\2\2")
buf.write("\u0a9c\u0a9d\f\3\2\2\u0a9d\u0a9e\7|\2\2\u0a9e\u0aa0\5")
buf.write("\u01fe\u0100\2\u0a9f\u0a9c\3\2\2\2\u0aa0\u0aa3\3\2\2\2")
buf.write("\u0aa1\u0a9f\3\2\2\2\u0aa1\u0aa2\3\2\2\2\u0aa2\u01fd\3")
buf.write("\2\2\2\u0aa3\u0aa1\3\2\2\2\u0aa4\u0aa5\7N\2\2\u0aa5\u0aa6")
buf.write("\7\u0084\2\2\u0aa6\u0ac3\5\u0208\u0105\2\u0aa7\u0aa8\7")
buf.write("O\2\2\u0aa8\u0aa9\7\u0084\2\2\u0aa9\u0ac3\5\u024e\u0128")
buf.write("\2\u0aaa\u0aab\7G\2\2\u0aab\u0aac\7\u0084\2\2\u0aac\u0ac3")
buf.write("\5\u0272\u013a\2\u0aad\u0aae\7\16\2\2\u0aae\u0aaf\7\u0084")
buf.write("\2\2\u0aaf\u0ac3\5\u023e\u0120\2\u0ab0\u0ab1\7U\2\2\u0ab1")
buf.write("\u0ab2\7\u0084\2\2\u0ab2\u0ac3\5\u023e\u0120\2\u0ab3\u0ab4")
buf.write("\7Y\2\2\u0ab4\u0ab5\7\u0084\2\2\u0ab5\u0ac3\5\u0256\u012c")
buf.write("\2\u0ab6\u0ab7\7X\2\2\u0ab7\u0ab8\7\u0084\2\2\u0ab8\u0ac3")
buf.write("\5b\62\2\u0ab9\u0aba\7W\2\2\u0aba\u0abb\7\u0084\2\2\u0abb")
buf.write("\u0ac3\5\u022c\u0117\2\u0abc\u0abd\7V\2\2\u0abd\u0abe")
buf.write("\7\u0084\2\2\u0abe\u0ac3\5\u0196\u00cc\2\u0abf\u0ac0\7")
buf.write("\u0090\2\2\u0ac0\u0ac1\7\u0084\2\2\u0ac1\u0ac3\5\u023e")
buf.write("\u0120\2\u0ac2\u0aa4\3\2\2\2\u0ac2\u0aa7\3\2\2\2\u0ac2")
buf.write("\u0aaa\3\2\2\2\u0ac2\u0aad\3\2\2\2\u0ac2\u0ab0\3\2\2\2")
buf.write("\u0ac2\u0ab3\3\2\2\2\u0ac2\u0ab6\3\2\2\2\u0ac2\u0ab9\3")
buf.write("\2\2\2\u0ac2\u0abc\3\2\2\2\u0ac2\u0abf\3\2\2\2\u0ac3\u01ff")
buf.write("\3\2\2\2\u0ac4\u0ac5\7L\2\2\u0ac5\u0ac6\5\u0208\u0105")
buf.write("\2\u0ac6\u0ac7\7|\2\2\u0ac7\u0ac8\5\u0202\u0102\2\u0ac8")
buf.write("\u0acc\3\2\2\2\u0ac9\u0aca\7L\2\2\u0aca\u0acc\5\u0208")
buf.write("\u0105\2\u0acb\u0ac4\3\2\2\2\u0acb\u0ac9\3\2\2\2\u0acc")
buf.write("\u0201\3\2\2\2\u0acd\u0ad0\5\u0272\u013a\2\u0ace\u0ad0")
buf.write("\5\u0204\u0103\2\u0acf\u0acd\3\2\2\2\u0acf\u0ace\3\2\2")
buf.write("\2\u0ad0\u0203\3\2\2\2\u0ad1\u0ad2\b\u0103\1\2\u0ad2\u0ad3")
buf.write("\5\u0272\u013a\2\u0ad3\u0ad4\7|\2\2\u0ad4\u0ad5\5\u0272")
buf.write("\u013a\2\u0ad5\u0adc\3\2\2\2\u0ad6\u0ad7\5\u0272\u013a")
buf.write("\2\u0ad7\u0ad8\7|\2\2\u0ad8\u0ad9\5\u0206\u0104\2\u0ad9")
buf.write("\u0adc\3\2\2\2\u0ada\u0adc\5\u0206\u0104\2\u0adb\u0ad1")
buf.write("\3\2\2\2\u0adb\u0ad6\3\2\2\2\u0adb\u0ada\3\2\2\2\u0adc")
buf.write("\u0ae5\3\2\2\2\u0add\u0ade\f\4\2\2\u0ade\u0adf\7|\2\2")
buf.write("\u0adf\u0ae4\5\u0272\u013a\2\u0ae0\u0ae1\f\3\2\2\u0ae1")
buf.write("\u0ae2\7|\2\2\u0ae2\u0ae4\5\u0206\u0104\2\u0ae3\u0add")
buf.write("\3\2\2\2\u0ae3\u0ae0\3\2\2\2\u0ae4\u0ae7\3\2\2\2\u0ae5")
buf.write("\u0ae3\3\2\2\2\u0ae5\u0ae6\3\2\2\2\u0ae6\u0205\3\2\2\2")
buf.write("\u0ae7\u0ae5\3\2\2\2\u0ae8\u0ae9\7}\2\2\u0ae9\u0aea\5")
buf.write("\u0272\u013a\2\u0aea\u0aeb\7|\2\2\u0aeb\u0aec\5\u01ac")
buf.write("\u00d7\2\u0aec\u0aed\7\u0084\2\2\u0aed\u0aee\5\u0272\u013a")
buf.write("\2\u0aee\u0aef\7|\2\2\u0aef\u0af1\5\u0272\u013a\2\u0af0")
buf.write("\u0af2\5\u01b4\u00db\2\u0af1\u0af0\3\2\2\2\u0af1\u0af2")
buf.write("\3\2\2\2\u0af2\u0af3\3\2\2\2\u0af3\u0af4\7\u0082\2\2\u0af4")
buf.write("\u0b03\3\2\2\2\u0af5\u0af6\7}\2\2\u0af6\u0af7\5\u0204")
buf.write("\u0103\2\u0af7\u0af8\7|\2\2\u0af8\u0af9\5\u01ac\u00d7")
buf.write("\2\u0af9\u0afa\7\u0084\2\2\u0afa\u0afb\5\u0272\u013a\2")
buf.write("\u0afb\u0afc\7|\2\2\u0afc\u0afe\5\u0272\u013a\2\u0afd")
buf.write("\u0aff\5\u01b4\u00db\2\u0afe\u0afd\3\2\2\2\u0afe\u0aff")
buf.write("\3\2\2\2\u0aff\u0b00\3\2\2\2\u0b00\u0b01\7\u0082\2\2\u0b01")
buf.write("\u0b03\3\2\2\2\u0b02\u0ae8\3\2\2\2\u0b02\u0af5\3\2\2\2")
buf.write("\u0b03\u0207\3\2\2\2\u0b04\u0b08\5\u023e\u0120\2\u0b05")
buf.write("\u0b08\5\u022c\u0117\2\u0b06\u0b08\7\u00c2\2\2\u0b07\u0b04")
buf.write("\3\2\2\2\u0b07\u0b05\3\2\2\2\u0b07\u0b06\3\2\2\2\u0b08")
buf.write("\u0209\3\2\2\2\u0b09\u0b0b\7I\2\2\u0b0a\u0b0c\t\b\2\2")
buf.write("\u0b0b\u0b0a\3\2\2\2\u0b0b\u0b0c\3\2\2\2\u0b0c\u020b\3")
buf.write("\2\2\2\u0b0d\u0b0e\7M\2\2\u0b0e\u0b0f\7}\2\2\u0b0f\u0b10")
buf.write("\5\u020e\u0108\2\u0b10\u0b11\7\u0082\2\2\u0b11\u020d\3")
buf.write("\2\2\2\u0b12\u0b14\5\u0252\u012a\2\u0b13\u0b12\3\2\2\2")
buf.write("\u0b13\u0b14\3\2\2\2\u0b14\u0b16\3\2\2\2\u0b15\u0b17\5")
buf.write("\u0210\u0109\2\u0b16\u0b15\3\2\2\2\u0b16\u0b17\3\2\2\2")
buf.write("\u0b17\u0b1c\3\2\2\2\u0b18\u0b19\7|\2\2\u0b19\u0b1b\5")
buf.write("\u0210\u0109\2\u0b1a\u0b18\3\2\2\2\u0b1b\u0b1e\3\2\2\2")
buf.write("\u0b1c\u0b1a\3\2\2\2\u0b1c\u0b1d\3\2\2\2\u0b1d\u020f\3")
buf.write("\2\2\2\u0b1e\u0b1c\3\2\2\2\u0b1f\u0b20\7O\2\2\u0b20\u0b21")
buf.write("\7\u0084\2\2\u0b21\u0b47\5\u024e\u0128\2\u0b22\u0b23\7")
buf.write("U\2\2\u0b23\u0b24\7\u0084\2\2\u0b24\u0b47\5\u023e\u0120")
buf.write("\2\u0b25\u0b26\7c\2\2\u0b26\u0b27\7\u0084\2\2\u0b27\u0b47")
buf.write("\5\u022c\u0117\2\u0b28\u0b29\7d\2\2\u0b29\u0b2a\7\u0084")
buf.write("\2\2\u0b2a\u0b47\5\u022c\u0117\2\u0b2b\u0b2c\7e\2\2\u0b2c")
buf.write("\u0b2d\7\u0084\2\2\u0b2d\u0b47\5\u022c\u0117\2\u0b2e\u0b2f")
buf.write("\7g\2\2\u0b2f\u0b30\7\u0084\2\2\u0b30\u0b47\5\u022c\u0117")
buf.write("\2\u0b31\u0b32\7h\2\2\u0b32\u0b33\7\u0084\2\2\u0b33\u0b47")
buf.write("\5\u0272\u013a\2\u0b34\u0b35\7\u00c0\2\2\u0b35\u0b36\7")
buf.write("\u0084\2\2\u0b36\u0b47\5\u022c\u0117\2\u0b37\u0b38\7Y")
buf.write("\2\2\u0b38\u0b39\7\u0084\2\2\u0b39\u0b47\5\u0256\u012c")
buf.write("\2\u0b3a\u0b3b\7f\2\2\u0b3b\u0b3c\7\u0084\2\2\u0b3c\u0b47")
buf.write("\5\u022c\u0117\2\u0b3d\u0b3e\7Q\2\2\u0b3e\u0b3f\7\u0084")
buf.write("\2\2\u0b3f\u0b47\5\u022c\u0117\2\u0b40\u0b41\7R\2\2\u0b41")
buf.write("\u0b42\7\u0084\2\2\u0b42\u0b47\5\u022c\u0117\2\u0b43\u0b44")
buf.write("\7P\2\2\u0b44\u0b45\7\u0084\2\2\u0b45\u0b47\5\u022c\u0117")
buf.write("\2\u0b46\u0b1f\3\2\2\2\u0b46\u0b22\3\2\2\2\u0b46\u0b25")
buf.write("\3\2\2\2\u0b46\u0b28\3\2\2\2\u0b46\u0b2b\3\2\2\2\u0b46")
buf.write("\u0b2e\3\2\2\2\u0b46\u0b31\3\2\2\2\u0b46\u0b34\3\2\2\2")
buf.write("\u0b46\u0b37\3\2\2\2\u0b46\u0b3a\3\2\2\2\u0b46\u0b3d\3")
buf.write("\2\2\2\u0b46\u0b40\3\2\2\2\u0b46\u0b43\3\2\2\2\u0b47\u0211")
buf.write("\3\2\2\2\u0b48\u0b49\7q\2\2\u0b49\u0b4a\7}\2\2\u0b4a\u0b4b")
buf.write("\5\u0214\u010b\2\u0b4b\u0b4c\7\u0082\2\2\u0b4c\u0b56\3")
buf.write("\2\2\2\u0b4d\u0b4e\7q\2\2\u0b4e\u0b4f\7}\2\2\u0b4f\u0b50")
buf.write("\7S\2\2\u0b50\u0b51\7\u0084\2\2\u0b51\u0b52\5\u0256\u012c")
buf.write("\2\u0b52\u0b53\7\u0082\2\2\u0b53\u0b54\5\u0202\u0102\2")
buf.write("\u0b54\u0b56\3\2\2\2\u0b55\u0b48\3\2\2\2\u0b55\u0b4d\3")
buf.write("\2\2\2\u0b56\u0213\3\2\2\2\u0b57\u0b59\5\u024e\u0128\2")
buf.write("\u0b58\u0b57\3\2\2\2\u0b58\u0b59\3\2\2\2\u0b59\u0b5b\3")
buf.write("\2\2\2\u0b5a\u0b5c\5\u0216\u010c\2\u0b5b\u0b5a\3\2\2\2")
buf.write("\u0b5b\u0b5c\3\2\2\2\u0b5c\u0b61\3\2\2\2\u0b5d\u0b5e\7")
buf.write("|\2\2\u0b5e\u0b60\5\u0216\u010c\2\u0b5f\u0b5d\3\2\2\2")
buf.write("\u0b60\u0b63\3\2\2\2\u0b61\u0b5f\3\2\2\2\u0b61\u0b62\3")
buf.write("\2\2\2\u0b62\u0215\3\2\2\2\u0b63\u0b61\3\2\2\2\u0b64\u0b65")
buf.write("\7O\2\2\u0b65\u0b66\7\u0084\2\2\u0b66\u0bb0\5\u024e\u0128")
buf.write("\2\u0b67\u0b68\7c\2\2\u0b68\u0b69\7\u0084\2\2\u0b69\u0bb0")
buf.write("\5\u022c\u0117\2\u0b6a\u0b6b\7U\2\2\u0b6b\u0b6c\7\u0084")
buf.write("\2\2\u0b6c\u0bb0\5\u023e\u0120\2\u0b6d\u0b6e\7Y\2\2\u0b6e")
buf.write("\u0b6f\7\u0084\2\2\u0b6f\u0bb0\5\u0256\u012c\2\u0b70\u0b71")
buf.write("\7i\2\2\u0b71\u0b72\7\u0084\2\2\u0b72\u0bb0\5\u0256\u012c")
buf.write("\2\u0b73\u0b74\7j\2\2\u0b74\u0b75\7\u0084\2\2\u0b75\u0bb0")
buf.write("\5\u0256\u012c\2\u0b76\u0b77\7k\2\2\u0b77\u0b78\7\u0084")
buf.write("\2\2\u0b78\u0bb0\5\u0256\u012c\2\u0b79\u0b7a\7l\2\2\u0b7a")
buf.write("\u0b7b\7\u0084\2\2\u0b7b\u0bb0\5\u0256\u012c\2\u0b7c\u0b7d")
buf.write("\7\u00be\2\2\u0b7d\u0b7e\7\u0084\2\2\u0b7e\u0bb0\5\u0256")
buf.write("\u012c\2\u0b7f\u0b80\7e\2\2\u0b80\u0b81\7\u0084\2\2\u0b81")
buf.write("\u0bb0\5\u0256\u012c\2\u0b82\u0b83\7a\2\2\u0b83\u0b84")
buf.write("\7\u0084\2\2\u0b84\u0bb0\5\u0256\u012c\2\u0b85\u0b86\7")
buf.write("E\2\2\u0b86\u0b87\7\u0084\2\2\u0b87\u0bb0\5\u0256\u012c")
buf.write("\2\u0b88\u0b89\7g\2\2\u0b89\u0b8a\7\u0084\2\2\u0b8a\u0bb0")
buf.write("\5\u0256\u012c\2\u0b8b\u0b8c\7n\2\2\u0b8c\u0b8d\7\u0084")
buf.write("\2\2\u0b8d\u0bb0\5\u0256\u012c\2\u0b8e\u0b8f\7o\2\2\u0b8f")
buf.write("\u0b90\7\u0084\2\2\u0b90\u0bb0\5\u0256\u012c\2\u0b91\u0b92")
buf.write("\7h\2\2\u0b92\u0b93\7\u0084\2\2\u0b93\u0bb0\5\u0272\u013a")
buf.write("\2\u0b94\u0b95\7p\2\2\u0b95\u0b96\7\u0084\2\2\u0b96\u0bb0")
buf.write("\5\u0256\u012c\2\u0b97\u0b98\7\u00c0\2\2\u0b98\u0b99\7")
buf.write("\u0084\2\2\u0b99\u0bb0\5\u0256\u012c\2\u0b9a\u0b9b\7f")
buf.write("\2\2\u0b9b\u0b9c\7\u0084\2\2\u0b9c\u0bb0\5\u0256\u012c")
buf.write("\2\u0b9d\u0b9e\7Q\2\2\u0b9e\u0b9f\7\u0084\2\2\u0b9f\u0bb0")
buf.write("\5\u0256\u012c\2\u0ba0\u0ba1\7K\2\2\u0ba1\u0ba2\7\u0084")
buf.write("\2\2\u0ba2\u0bb0\5\u0256\u012c\2\u0ba3\u0ba4\7J\2\2\u0ba4")
buf.write("\u0ba5\7\u0084\2\2\u0ba5\u0bb0\5\u0256\u012c\2\u0ba6\u0ba7")
buf.write("\7T\2\2\u0ba7\u0ba8\7\u0084\2\2\u0ba8\u0bb0\5\u0256\u012c")
buf.write("\2\u0ba9\u0baa\7R\2\2\u0baa\u0bab\7\u0084\2\2\u0bab\u0bb0")
buf.write("\5\u0256\u012c\2\u0bac\u0bad\7P\2\2\u0bad\u0bae\7\u0084")
buf.write("\2\2\u0bae\u0bb0\5\u0256\u012c\2\u0baf\u0b64\3\2\2\2\u0baf")
buf.write("\u0b67\3\2\2\2\u0baf\u0b6a\3\2\2\2\u0baf\u0b6d\3\2\2\2")
buf.write("\u0baf\u0b70\3\2\2\2\u0baf\u0b73\3\2\2\2\u0baf\u0b76\3")
buf.write("\2\2\2\u0baf\u0b79\3\2\2\2\u0baf\u0b7c\3\2\2\2\u0baf\u0b7f")
buf.write("\3\2\2\2\u0baf\u0b82\3\2\2\2\u0baf\u0b85\3\2\2\2\u0baf")
buf.write("\u0b88\3\2\2\2\u0baf\u0b8b\3\2\2\2\u0baf\u0b8e\3\2\2\2")
buf.write("\u0baf\u0b91\3\2\2\2\u0baf\u0b94\3\2\2\2\u0baf\u0b97\3")
buf.write("\2\2\2\u0baf\u0b9a\3\2\2\2\u0baf\u0b9d\3\2\2\2\u0baf\u0ba0")
buf.write("\3\2\2\2\u0baf\u0ba3\3\2\2\2\u0baf\u0ba6\3\2\2\2\u0baf")
buf.write("\u0ba9\3\2\2\2\u0baf\u0bac\3\2\2\2\u0bb0\u0217\3\2\2\2")
buf.write("\u0bb1\u0bb5\7\64\2\2\u0bb2\u0bb3\7\63\2\2\u0bb3\u0bb5")
buf.write("\7\u00a1\2\2\u0bb4\u0bb1\3\2\2\2\u0bb4\u0bb2\3\2\2\2\u0bb5")
buf.write("\u0bb6\3\2\2\2\u0bb6\u0bcc\5\u01b2\u00da\2\u0bb7\u0bbb")
buf.write("\7\64\2\2\u0bb8\u0bb9\7\63\2\2\u0bb9\u0bbb\7\u00a1\2\2")
buf.write("\u0bba\u0bb7\3\2\2\2\u0bba\u0bb8\3\2\2\2\u0bbb\u0bbc\3")
buf.write("\2\2\2\u0bbc\u0bbd\5\u01b2\u00da\2\u0bbd\u0bbe\7}\2\2")
buf.write("\u0bbe\u0bbf\5\u0220\u0111\2\u0bbf\u0bc0\7\u0082\2\2\u0bc0")
buf.write("\u0bcc\3\2\2\2\u0bc1\u0bc5\7\64\2\2\u0bc2\u0bc3\7\63\2")
buf.write("\2\u0bc3\u0bc5\7\u00a1\2\2\u0bc4\u0bc1\3\2\2\2\u0bc4\u0bc2")
buf.write("\3\2\2\2\u0bc5\u0bc6\3\2\2\2\u0bc6\u0bc7\5\u021a\u010e")
buf.write("\2\u0bc7\u0bc8\7}\2\2\u0bc8\u0bc9\5\u0220\u0111\2\u0bc9")
buf.write("\u0bca\7\u0082\2\2\u0bca\u0bcc\3\2\2\2\u0bcb\u0bb4\3\2")
buf.write("\2\2\u0bcb\u0bba\3\2\2\2\u0bcb\u0bc4\3\2\2\2\u0bcc\u0219")
buf.write("\3\2\2\2\u0bcd\u0bce\5\u01b2\u00da\2\u0bce\u0bcf\7|\2")
buf.write("\2\u0bcf\u021b\3\2\2\2\u0bd0\u0bd4\7\64\2\2\u0bd1\u0bd2")
buf.write("\7\63\2\2\u0bd2\u0bd4\7\u00a1\2\2\u0bd3\u0bd0\3\2\2\2")
buf.write("\u0bd3\u0bd1\3\2\2\2\u0bd4\u0bd5\3\2\2\2\u0bd5\u0bd6\5")
buf.write("\u023e\u0120\2\u0bd6\u021d\3\2\2\2\u0bd7\u0bd8\7\64\2")
buf.write("\2\u0bd8\u0bd9\7}\2\2\u0bd9\u0bda\5\u0220\u0111\2\u0bda")
buf.write("\u0bdc\7\u0082\2\2\u0bdb\u0bdd\7|\2\2\u0bdc\u0bdb\3\2")
buf.write("\2\2\u0bdc\u0bdd\3\2\2\2\u0bdd\u0bde\3\2\2\2\u0bde\u0bdf")
buf.write("\5\u0272\u013a\2\u0bdf\u021f\3\2\2\2\u0be0\u0be5\5\u023e")
buf.write("\u0120\2\u0be1\u0be2\7|\2\2\u0be2\u0be4\5\u023e\u0120")
buf.write("\2\u0be3\u0be1\3\2\2\2\u0be4\u0be7\3\2\2\2\u0be5\u0be3")
buf.write("\3\2\2\2\u0be5\u0be6\3\2\2\2\u0be6\u0221\3\2\2\2\u0be7")
buf.write("\u0be5\3\2\2\2\u0be8\u0bec\7s\2\2\u0be9\u0bea\7\16\2\2")
buf.write("\u0bea\u0bec\7c\2\2\u0beb\u0be8\3\2\2\2\u0beb\u0be9\3")
buf.write("\2\2\2\u0bec\u0bed\3\2\2\2\u0bed\u0bf8\5\u024e\u0128\2")
buf.write("\u0bee\u0bf2\7s\2\2\u0bef\u0bf0\7\16\2\2\u0bf0\u0bf2\7")
buf.write("c\2\2\u0bf1\u0bee\3\2\2\2\u0bf1\u0bef\3\2\2\2\u0bf2\u0bf3")
buf.write("\3\2\2\2\u0bf3\u0bf4\7}\2\2\u0bf4\u0bf5\5\u0250\u0129")
buf.write("\2\u0bf5\u0bf6\7\u0082\2\2\u0bf6\u0bf8\3\2\2\2\u0bf7\u0beb")
buf.write("\3\2\2\2\u0bf7\u0bf1\3\2\2\2\u0bf8\u0223\3\2\2\2\u0bf9")
buf.write("\u0bfa\7=\2\2\u0bfa\u0225\3\2\2\2\u0bfb\u0bfc\7^\2\2\u0bfc")
buf.write("\u0bfd\7}\2\2\u0bfd\u0bfe\5\u0228\u0115\2\u0bfe\u0bff")
buf.write("\7\u0082\2\2\u0bff\u0227\3\2\2\2\u0c00\u0c02\5\u0252\u012a")
buf.write("\2\u0c01\u0c00\3\2\2\2\u0c01\u0c02\3\2\2\2\u0c02\u0c04")
buf.write("\3\2\2\2\u0c03\u0c05\5\u022a\u0116\2\u0c04\u0c03\3\2\2")
buf.write("\2\u0c04\u0c05\3\2\2\2\u0c05\u0c0a\3\2\2\2\u0c06\u0c07")
buf.write("\7|\2\2\u0c07\u0c09\5\u022a\u0116\2\u0c08\u0c06\3\2\2")
buf.write("\2\u0c09\u0c0c\3\2\2\2\u0c0a\u0c08\3\2\2\2\u0c0a\u0c0b")
buf.write("\3\2\2\2\u0c0b\u0229\3\2\2\2\u0c0c\u0c0a\3\2\2\2\u0c0d")
buf.write("\u0c0e\7O\2\2\u0c0e\u0c0f\7\u0084\2\2\u0c0f\u0c19\5\u024e")
buf.write("\u0128\2\u0c10\u0c11\7U\2\2\u0c11\u0c12\7\u0084\2\2\u0c12")
buf.write("\u0c19\5\u023e\u0120\2\u0c13\u0c14\7d\2\2\u0c14\u0c15")
buf.write("\7\u0084\2\2\u0c15\u0c19\5\u022c\u0117\2\u0c16\u0c17\7")
buf.write("Y\2\2\u0c17\u0c19\5\u0256\u012c\2\u0c18\u0c0d\3\2\2\2")
buf.write("\u0c18\u0c10\3\2\2\2\u0c18\u0c13\3\2\2\2\u0c18\u0c16\3")
buf.write("\2\2\2\u0c19\u022b\3\2\2\2\u0c1a\u0c1e\5\u022e\u0118\2")
buf.write("\u0c1b\u0c1d\5\u0232\u011a\2\u0c1c\u0c1b\3\2\2\2\u0c1d")
buf.write("\u0c20\3\2\2\2\u0c1e\u0c1c\3\2\2\2\u0c1e\u0c1f\3\2\2\2")
buf.write("\u0c1f\u022d\3\2\2\2\u0c20\u0c1e\3\2\2\2\u0c21\u0c27\5")
buf.write("\u0230\u0119\2\u0c22\u0c23\7}\2\2\u0c23\u0c24\5\u022c")
buf.write("\u0117\2\u0c24\u0c25\7\u0082\2\2\u0c25\u0c27\3\2\2\2\u0c26")
buf.write("\u0c21\3\2\2\2\u0c26\u0c22\3\2\2\2\u0c27\u022f\3\2\2\2")
buf.write("\u0c28\u0c2c\7\u00b3\2\2\u0c29\u0c2c\5\u02a0\u0151\2\u0c2a")
buf.write("\u0c2c\5\u029a\u014e\2\u0c2b\u0c28\3\2\2\2\u0c2b\u0c29")
buf.write("\3\2\2\2\u0c2b\u0c2a\3\2\2\2\u0c2c\u0231\3\2\2\2\u0c2d")
buf.write("\u0c2e\5\u022e\u0118\2\u0c2e\u0c2f\7\u0087\2\2\u0c2f\u0c30")
buf.write("\7\u00ba\2\2\u0c30\u0c31\7\u0087\2\2\u0c31\u0c32\7\u00bb")
buf.write("\2\2\u0c32\u0233\3\2\2\2\u0c33\u0c34\7\\\2\2\u0c34\u0c3c")
buf.write("\5\u0236\u011c\2\u0c35\u0c36\7\\\2\2\u0c36\u0c37\5\u0236")
buf.write("\u011c\2\u0c37\u0c38\7}\2\2\u0c38\u0c39\5\u0238\u011d")
buf.write("\2\u0c39\u0c3a\7\u0082\2\2\u0c3a\u0c3c\3\2\2\2\u0c3b\u0c33")
buf.write("\3\2\2\2\u0c3b\u0c35\3\2\2\2\u0c3c\u0235\3\2\2\2\u0c3d")
buf.write("\u0c3e\7\u00be\2\2\u0c3e\u0237\3\2\2\2\u0c3f\u0c41\5\u023a")
buf.write("\u011e\2\u0c40\u0c3f\3\2\2\2\u0c40\u0c41\3\2\2\2\u0c41")
buf.write("\u0c46\3\2\2\2\u0c42\u0c43\7|\2\2\u0c43\u0c45\5\u023a")
buf.write("\u011e\2\u0c44\u0c42\3\2\2\2\u0c45\u0c48\3\2\2\2\u0c46")
buf.write("\u0c44\3\2\2\2\u0c46\u0c47\3\2\2\2\u0c47\u0239\3\2\2\2")
buf.write("\u0c48\u0c46\3\2\2\2\u0c49\u0c58\5\u0272\u013a\2\u0c4a")
buf.write("\u0c58\7\u009d\2\2\u0c4b\u0c4c\7\u00c2\2\2\u0c4c\u0c58")
buf.write("\5\u023e\u0120\2\u0c4d\u0c4e\7\u00be\2\2\u0c4e\u0c4f\7")
buf.write("\u0084\2\2\u0c4f\u0c58\5\u0272\u013a\2\u0c50\u0c51\7\u00be")
buf.write("\2\2\u0c51\u0c52\7\u0084\2\2\u0c52\u0c58\7\u009d\2\2\u0c53")
buf.write("\u0c54\7\u00be\2\2\u0c54\u0c55\7\u0084\2\2\u0c55\u0c56")
buf.write("\7\u00c2\2\2\u0c56\u0c58\5\u023e\u0120\2\u0c57\u0c49\3")
buf.write("\2\2\2\u0c57\u0c4a\3\2\2\2\u0c57\u0c4b\3\2\2\2\u0c57\u0c4d")
buf.write("\3\2\2\2\u0c57\u0c50\3\2\2\2\u0c57\u0c53\3\2\2\2\u0c58")
buf.write("\u023b\3\2\2\2\u0c59\u0c5a\7\65\2\2\u0c5a\u0c5b\7}\2\2")
buf.write("\u0c5b\u0c5c\5\u0272\u013a\2\u0c5c\u0c5d\7\u0082\2\2\u0c5d")
buf.write("\u0c5e\5\u023e\u0120\2\u0c5e\u0c5f\7|\2\2\u0c5f\u0c60")
buf.write("\5\u023e\u0120\2\u0c60\u0c61\7|\2\2\u0c61\u0c62\5\u023e")
buf.write("\u0120\2\u0c62\u023d\3\2\2\2\u0c63\u0c64\5\u0240\u0121")
buf.write("\2\u0c64\u023f\3\2\2\2\u0c65\u0c66\7\u00bc\2\2\u0c66\u0241")
buf.write("\3\2\2\2\u0c67\u0c69\5\u0240\u0121\2\u0c68\u0c67\3\2\2")
buf.write("\2\u0c68\u0c69\3\2\2\2\u0c69\u0c6a\3\2\2\2\u0c6a\u0c6c")
buf.write("\7\u00be\2\2\u0c6b\u0c6d\5\u0244\u0123\2\u0c6c\u0c6b\3")
buf.write("\2\2\2\u0c6c\u0c6d\3\2\2\2\u0c6d\u0c6f\3\2\2\2\u0c6e\u0c70")
buf.write("\5\u019e\u00d0\2\u0c6f\u0c6e\3\2\2\2\u0c6f\u0c70\3\2\2")
buf.write("\2\u0c70\u0c71\3\2\2\2\u0c71\u0c72\7\u0084\2\2\u0c72\u0c86")
buf.write("\5\u0272\u013a\2\u0c73\u0c75\7\u00be\2\2\u0c74\u0c76\5")
buf.write("\u0244\u0123\2\u0c75\u0c74\3\2\2\2\u0c75\u0c76\3\2\2\2")
buf.write("\u0c76\u0c77\3\2\2\2\u0c77\u0c78\7~\2\2\u0c78\u0c79\5")
buf.write("\u02a0\u0151\2\u0c79\u0c7a\7\u0084\2\2\u0c7a\u0c7b\5\u0272")
buf.write("\u013a\2\u0c7b\u0c86\3\2\2\2\u0c7c\u0c7d\7\u00be\2\2\u0c7d")
buf.write("\u0c7e\7}\2\2\u0c7e\u0c7f\5\u01e2\u00f2\2\u0c7f\u0c80")
buf.write("\7\u0082\2\2\u0c80\u0c81\7~\2\2\u0c81\u0c82\5\u02a0\u0151")
buf.write("\2\u0c82\u0c83\7\u0084\2\2\u0c83\u0c84\5\u0272\u013a\2")
buf.write("\u0c84\u0c86\3\2\2\2\u0c85\u0c68\3\2\2\2\u0c85\u0c73\3")
buf.write("\2\2\2\u0c85\u0c7c\3\2\2\2\u0c86\u0243\3\2\2\2\u0c87\u0c88")
buf.write("\7}\2\2\u0c88\u0c8c\5\u0246\u0124\2\u0c89\u0c8b\5\u0248")
buf.write("\u0125\2\u0c8a\u0c89\3\2\2\2\u0c8b\u0c8e\3\2\2\2\u0c8c")
buf.write("\u0c8a\3\2\2\2\u0c8c\u0c8d\3\2\2\2\u0c8d\u0c8f\3\2\2\2")
buf.write("\u0c8e\u0c8c\3\2\2\2\u0c8f\u0c90\7\u0082\2\2\u0c90\u0245")
buf.write("\3\2\2\2\u0c91\u0c93\5\u0272\u013a\2\u0c92\u0c94\7\u0083")
buf.write("\2\2\u0c93\u0c92\3\2\2\2\u0c93\u0c94\3\2\2\2\u0c94\u0c96")
buf.write("\3\2\2\2\u0c95\u0c97\5\u0272\u013a\2\u0c96\u0c95\3\2\2")
buf.write("\2\u0c96\u0c97\3\2\2\2\u0c97\u0caa\3\2\2\2\u0c98\u0c9a")
buf.write("\7\u0083\2\2\u0c99\u0c9b\5\u0272\u013a\2\u0c9a\u0c99\3")
buf.write("\2\2\2\u0c9a\u0c9b\3\2\2\2\u0c9b\u0caa\3\2\2\2\u0c9c\u0c9e")
buf.write("\5\u0272\u013a\2\u0c9d\u0c9c\3\2\2\2\u0c9d\u0c9e\3\2\2")
buf.write("\2\u0c9e\u0c9f\3\2\2\2\u0c9f\u0ca0\7\u0083\2\2\u0ca0\u0ca1")
buf.write("\5\u0272\u013a\2\u0ca1\u0ca2\7\u0083\2\2\u0ca2\u0ca3\5")
buf.write("\u0272\u013a\2\u0ca3\u0caa\3\2\2\2\u0ca4\u0ca6\5\u0272")
buf.write("\u013a\2\u0ca5\u0ca4\3\2\2\2\u0ca5\u0ca6\3\2\2\2\u0ca6")
buf.write("\u0ca7\3\2\2\2\u0ca7\u0ca8\7 \2\2\u0ca8\u0caa\5\u0272")
buf.write("\u013a\2\u0ca9\u0c91\3\2\2\2\u0ca9\u0c98\3\2\2\2\u0ca9")
buf.write("\u0c9d\3\2\2\2\u0ca9\u0ca5\3\2\2\2\u0caa\u0247\3\2\2\2")
buf.write("\u0cab\u0cac\7|\2\2\u0cac\u0cad\5\u02a8\u0155\2\u0cad")
buf.write("\u0249\3\2\2\2\u0cae\u0caf\7!\2\2\u0caf\u0cb0\5\u023e")
buf.write("\u0120\2\u0cb0\u0cb1\7\u00a1\2\2\u0cb1\u0cb2\5\u01b2\u00da")
buf.write("\2\u0cb2\u024b\3\2\2\2\u0cb3\u0cb4\7r\2\2\u0cb4\u0cbb")
buf.write("\5\u024e\u0128\2\u0cb5\u0cb6\7r\2\2\u0cb6\u0cb7\7}\2\2")
buf.write("\u0cb7\u0cb8\5\u0250\u0129\2\u0cb8\u0cb9\7\u0082\2\2\u0cb9")
buf.write("\u0cbb\3\2\2\2\u0cba\u0cb3\3\2\2\2\u0cba\u0cb5\3\2\2\2")
buf.write("\u0cbb\u024d\3\2\2\2\u0cbc\u0cbf\5\u0258\u012d\2\u0cbd")
buf.write("\u0cbf\7\u00c2\2\2\u0cbe\u0cbc\3\2\2\2\u0cbe\u0cbd\3\2")
buf.write("\2\2\u0cbf\u024f\3\2\2\2\u0cc0\u0cc2\5\u0252\u012a\2\u0cc1")
buf.write("\u0cc0\3\2\2\2\u0cc1\u0cc2\3\2\2\2\u0cc2\u0cc4\3\2\2\2")
buf.write("\u0cc3\u0cc5\5\u0254\u012b\2\u0cc4\u0cc3\3\2\2\2\u0cc5")
buf.write("\u0cc6\3\2\2\2\u0cc6\u0cc4\3\2\2\2\u0cc6\u0cc7\3\2\2\2")
buf.write("\u0cc7\u0251\3\2\2\2\u0cc8\u0cca\5\u024e\u0128\2\u0cc9")
buf.write("\u0ccb\7|\2\2\u0cca\u0cc9\3\2\2\2\u0cca\u0ccb\3\2\2\2")
buf.write("\u0ccb\u0253\3\2\2\2\u0ccc\u0ccd\7O\2\2\u0ccd\u0cce\7")
buf.write("\u0084\2\2\u0cce\u0cd6\5\u024e\u0128\2\u0ccf\u0cd0\7U")
buf.write("\2\2\u0cd0\u0cd1\7\u0084\2\2\u0cd1\u0cd6\5\u023e\u0120")
buf.write("\2\u0cd2\u0cd3\7Y\2\2\u0cd3\u0cd4\7\u0084\2\2\u0cd4\u0cd6")
buf.write("\5\u0256\u012c\2\u0cd5\u0ccc\3\2\2\2\u0cd5\u0ccf\3\2\2")
buf.write("\2\u0cd5\u0cd2\3\2\2\2\u0cd6\u0255\3\2\2\2\u0cd7\u0cda")
buf.write("\5\u01b2\u00da\2\u0cd8\u0cda\5\u01aa\u00d6\2\u0cd9\u0cd7")
buf.write("\3\2\2\2\u0cd9\u0cd8\3\2\2\2\u0cda\u0257\3\2\2\2\u0cdb")
buf.write("\u0cdc\b\u012d\1\2\u0cdc\u0ce0\5\u025a\u012e\2\u0cdd\u0cde")
buf.write("\t\3\2\2\u0cde\u0ce0\5\u025a\u012e\2\u0cdf\u0cdb\3\2\2")
buf.write("\2\u0cdf\u0cdd\3\2\2\2\u0ce0\u0ce6\3\2\2\2\u0ce1\u0ce2")
buf.write("\f\3\2\2\u0ce2\u0ce3\t\3\2\2\u0ce3\u0ce5\5\u025a\u012e")
buf.write("\2\u0ce4\u0ce1\3\2\2\2\u0ce5\u0ce8\3\2\2\2\u0ce6\u0ce4")
buf.write("\3\2\2\2\u0ce6\u0ce7\3\2\2\2\u0ce7\u0259\3\2\2\2\u0ce8")
buf.write("\u0ce6\3\2\2\2\u0ce9\u0cea\b\u012e\1\2\u0cea\u0ceb\5\u025c")
buf.write("\u012f\2\u0ceb\u0cf6\3\2\2\2\u0cec\u0ced\f\4\2\2\u0ced")
buf.write("\u0cee\t\t\2\2\u0cee\u0cf5\5\u025c\u012f\2\u0cef\u0cf0")
buf.write("\f\3\2\2\u0cf0\u0cf1\7\u0087\2\2\u0cf1\u0cf2\7\u0087\2")
buf.write("\2\u0cf2\u0cf3\3\2\2\2\u0cf3\u0cf5\5\u025e\u0130\2\u0cf4")
buf.write("\u0cec\3\2\2\2\u0cf4\u0cef\3\2\2\2\u0cf5\u0cf8\3\2\2\2")
buf.write("\u0cf6\u0cf4\3\2\2\2\u0cf6\u0cf7\3\2\2\2\u0cf7\u025b\3")
buf.write("\2\2\2\u0cf8\u0cf6\3\2\2\2\u0cf9\u0cff\5\u025e\u0130\2")
buf.write("\u0cfa\u0cfb\5\u025e\u0130\2\u0cfb\u0cfc\7\u0089\2\2\u0cfc")
buf.write("\u0cfd\5\u025c\u012f\2\u0cfd\u0cff\3\2\2\2\u0cfe\u0cf9")
buf.write("\3\2\2\2\u0cfe\u0cfa\3\2\2\2\u0cff\u025d\3\2\2\2\u0d00")
buf.write("\u0d09\7\u00bc\2\2\u0d01\u0d09\7\u00b3\2\2\u0d02\u0d09")
buf.write("\5\u02a0\u0151\2\u0d03\u0d09\5\u029a\u014e\2\u0d04\u0d05")
buf.write("\7}\2\2\u0d05\u0d06\5\u0258\u012d\2\u0d06\u0d07\7\u0082")
buf.write("\2\2\u0d07\u0d09\3\2\2\2\u0d08\u0d00\3\2\2\2\u0d08\u0d01")
buf.write("\3\2\2\2\u0d08\u0d02\3\2\2\2\u0d08\u0d03\3\2\2\2\u0d08")
buf.write("\u0d04\3\2\2\2\u0d09\u025f\3\2\2\2\u0d0a\u0d0b\7\13\2")
buf.write("\2\u0d0b\u0d0c\5\u0262\u0132\2\u0d0c\u0d0d\5\u0264\u0133")
buf.write("\2\u0d0d\u0d14\3\2\2\2\u0d0e\u0d0f\7\3\2\2\u0d0f\u0d10")
buf.write("\7\13\2\2\u0d10\u0d11\5\u0262\u0132\2\u0d11\u0d12\5\u0264")
buf.write("\u0133\2\u0d12\u0d14\3\2\2\2\u0d13\u0d0a\3\2\2\2\u0d13")
buf.write("\u0d0e\3\2\2\2\u0d14\u0261\3\2\2\2\u0d15\u0d16\7\u00be")
buf.write("\2\2\u0d16\u0263\3\2\2\2\u0d17\u0d19\5B\"\2\u0d18\u0d1a")
buf.write("\5\u013e\u00a0\2\u0d19\u0d18\3\2\2\2\u0d19\u0d1a\3\2\2")
buf.write("\2\u0d1a\u0d1b\3\2\2\2\u0d1b\u0d1c\5\u00dan\2\u0d1c\u0d22")
buf.write("\3\2\2\2\u0d1d\u0d1e\5B\"\2\u0d1e\u0d1f\5\16\b\2\u0d1f")
buf.write("\u0d20\5\u00dan\2\u0d20\u0d22\3\2\2\2\u0d21\u0d17\3\2")
buf.write("\2\2\u0d21\u0d1d\3\2\2\2\u0d22\u0265\3\2\2\2\u0d23\u0d24")
buf.write("\7<\2\2\u0d24\u0d25\7\u00b3\2\2\u0d25\u0267\3\2\2\2\u0d26")
buf.write("\u0d27\7+\2\2\u0d27\u0d2b\5\u026a\u0136\2\u0d28\u0d29")
buf.write("\7+\2\2\u0d29\u0d2b\7,\2\2\u0d2a\u0d26\3\2\2\2\u0d2a\u0d28")
buf.write("\3\2\2\2\u0d2b\u0269\3\2\2\2\u0d2c\u0d31\5\u026c\u0137")
buf.write("\2\u0d2d\u0d2e\7|\2\2\u0d2e\u0d30\5\u026c\u0137\2\u0d2f")
buf.write("\u0d2d\3\2\2\2\u0d30\u0d33\3\2\2\2\u0d31\u0d2f\3\2\2\2")
buf.write("\u0d31\u0d32\3\2\2\2\u0d32\u026b\3\2\2\2\u0d33\u0d31\3")
buf.write("\2\2\2\u0d34\u0d35\5\u0112\u008a\2\u0d35\u0d36\5\u026e")
buf.write("\u0138\2\u0d36\u0d3d\3\2\2\2\u0d37\u0d38\5\u0112\u008a")
buf.write("\2\u0d38\u0d39\7}\2\2\u0d39\u0d3a\5\u026e\u0138\2\u0d3a")
buf.write("\u0d3b\7\u0082\2\2\u0d3b\u0d3d\3\2\2\2\u0d3c\u0d34\3\2")
buf.write("\2\2\u0d3c\u0d37\3\2\2\2\u0d3d\u026d\3\2\2\2\u0d3e\u0d40")
buf.write("\5\u0270\u0139\2\u0d3f\u0d3e\3\2\2\2\u0d3f\u0d40\3\2\2")
buf.write("\2\u0d40\u0d45\3\2\2\2\u0d41\u0d42\7|\2\2\u0d42\u0d44")
buf.write("\5\u0270\u0139\2\u0d43\u0d41\3\2\2\2\u0d44\u0d47\3\2\2")
buf.write("\2\u0d45\u0d43\3\2\2\2\u0d45\u0d46\3\2\2\2\u0d46\u026f")
buf.write("\3\2\2\2\u0d47\u0d45\3\2\2\2\u0d48\u0d49\7\u00be\2\2\u0d49")
buf.write("\u0d4a\7\u0085\2\2\u0d4a\u0d4b\7\u00be\2\2\u0d4b\u0271")
buf.write("\3\2\2\2\u0d4c\u0d4d\b\u013a\1\2\u0d4d\u0d4e\5\u0276\u013c")
buf.write("\2\u0d4e\u0d55\3\2\2\2\u0d4f\u0d50\f\3\2\2\u0d50\u0d51")
buf.write("\5\u0274\u013b\2\u0d51\u0d52\5\u0276\u013c\2\u0d52\u0d54")
buf.write("\3\2\2\2\u0d53\u0d4f\3\2\2\2\u0d54\u0d57\3\2\2\2\u0d55")
buf.write("\u0d53\3\2\2\2\u0d55\u0d56\3\2\2\2\u0d56\u0273\3\2\2\2")
buf.write("\u0d57\u0d55\3\2\2\2\u0d58\u0d59\7\35\2\2\u0d59\u0275")
buf.write("\3\2\2\2\u0d5a\u0d5f\5\u0278\u013d\2\u0d5b\u0d5c\t\5\2")
buf.write("\2\u0d5c\u0d5e\5\u0278\u013d\2\u0d5d\u0d5b\3\2\2\2\u0d5e")
buf.write("\u0d61\3\2\2\2\u0d5f\u0d5d\3\2\2\2\u0d5f\u0d60\3\2\2\2")
buf.write("\u0d60\u0277\3\2\2\2\u0d61\u0d5f\3\2\2\2\u0d62\u0d67\5")
buf.write("\u027a\u013e\2\u0d63\u0d64\7\u008c\2\2\u0d64\u0d66\5\u027a")
buf.write("\u013e\2\u0d65\u0d63\3\2\2\2\u0d66\u0d69\3\2\2\2\u0d67")
buf.write("\u0d65\3\2\2\2\u0d67\u0d68\3\2\2\2\u0d68\u0279\3\2\2\2")
buf.write("\u0d69\u0d67\3\2\2\2\u0d6a\u0d6f\5\u027c\u013f\2\u0d6b")
buf.write("\u0d6c\7\u008b\2\2\u0d6c\u0d6e\5\u027c\u013f\2\u0d6d\u0d6b")
buf.write("\3\2\2\2\u0d6e\u0d71\3\2\2\2\u0d6f\u0d6d\3\2\2\2\u0d6f")
buf.write("\u0d70\3\2\2\2\u0d70\u027b\3\2\2\2\u0d71\u0d6f\3\2\2\2")
buf.write("\u0d72\u0d74\7\u008a\2\2\u0d73\u0d72\3\2\2\2\u0d73\u0d74")
buf.write("\3\2\2\2\u0d74\u0d75\3\2\2\2\u0d75\u0d76\5\u0280\u0141")
buf.write("\2\u0d76\u027d\3\2\2\2\u0d77\u0d78\t\n\2\2\u0d78\u027f")
buf.write("\3\2\2\2\u0d79\u0d7f\5\u0282\u0142\2\u0d7a\u0d7b\5\u027e")
buf.write("\u0140\2\u0d7b\u0d7c\5\u0282\u0142\2\u0d7c\u0d7e\3\2\2")
buf.write("\2\u0d7d\u0d7a\3\2\2\2\u0d7e\u0d81\3\2\2\2\u0d7f\u0d7d")
buf.write("\3\2\2\2\u0d7f\u0d80\3\2\2\2\u0d80\u0281\3\2\2\2\u0d81")
buf.write("\u0d7f\3\2\2\2\u0d82\u0d8e\5\u0284\u0143\2\u0d83\u0d85")
buf.write("\7\u0087\2\2\u0d84\u0d86\7\u00ba\2\2\u0d85\u0d84\3\2\2")
buf.write("\2\u0d85\u0d86\3\2\2\2\u0d86\u0d87\3\2\2\2\u0d87\u0d89")
buf.write("\7\u0087\2\2\u0d88\u0d8a\7\u00bb\2\2\u0d89\u0d88\3\2\2")
buf.write("\2\u0d89\u0d8a\3\2\2\2\u0d8a\u0d8b\3\2\2\2\u0d8b\u0d8d")
buf.write("\5\u0284\u0143\2\u0d8c\u0d83\3\2\2\2\u0d8d\u0d90\3\2\2")
buf.write("\2\u0d8e\u0d8c\3\2\2\2\u0d8e\u0d8f\3\2\2\2\u0d8f\u0283")
buf.write("\3\2\2\2\u0d90\u0d8e\3\2\2\2\u0d91\u0d93\5\u0286\u0144")
buf.write("\2\u0d92\u0d91\3\2\2\2\u0d92\u0d93\3\2\2\2\u0d93\u0d94")
buf.write("\3\2\2\2\u0d94\u0d99\5\u0288\u0145\2\u0d95\u0d96\t\3\2")
buf.write("\2\u0d96\u0d98\5\u0288\u0145\2\u0d97\u0d95\3\2\2\2\u0d98")
buf.write("\u0d9b\3\2\2\2\u0d99\u0d97\3\2\2\2\u0d99\u0d9a\3\2\2\2")
buf.write("\u0d9a\u0285\3\2\2\2\u0d9b\u0d99\3\2\2\2\u0d9c\u0d9d\t")
buf.write("\3\2\2\u0d9d\u0287\3\2\2\2\u0d9e\u0da3\5\u028a\u0146\2")
buf.write("\u0d9f\u0da0\t\t\2\2\u0da0\u0da2\5\u028a\u0146\2\u0da1")
buf.write("\u0d9f\3\2\2\2\u0da2\u0da5\3\2\2\2\u0da3\u0da1\3\2\2\2")
buf.write("\u0da3\u0da4\3\2\2\2\u0da4\u0289\3\2\2\2\u0da5\u0da3\3")
buf.write("\2\2\2\u0da6\u0dab\5\u028c\u0147\2\u0da7\u0da8\7\u0089")
buf.write("\2\2\u0da8\u0daa\5\u028c\u0147\2\u0da9\u0da7\3\2\2\2\u0daa")
buf.write("\u0dad\3\2\2\2\u0dab\u0da9\3\2\2\2\u0dab\u0dac\3\2\2\2")
buf.write("\u0dac\u028b\3\2\2\2\u0dad\u0dab\3\2\2\2\u0dae\u0db3\5")
buf.write("\u0290\u0149\2\u0daf\u0db0\5\u028e\u0148\2\u0db0\u0db1")
buf.write("\5\u0290\u0149\2\u0db1\u0db3\3\2\2\2\u0db2\u0dae\3\2\2")
buf.write("\2\u0db2\u0daf\3\2\2\2\u0db3\u028d\3\2\2\2\u0db4\u0db5")
buf.write("\7\35\2\2\u0db5\u028f\3\2\2\2\u0db6\u0dc1\5\u02b0\u0159")
buf.write("\2\u0db7\u0dc1\5\u02a0\u0151\2\u0db8\u0dc1\5\u029a\u014e")
buf.write("\2\u0db9\u0dba\7}\2\2\u0dba\u0dbb\5\u0272\u013a\2\u0dbb")
buf.write("\u0dbc\7\u0082\2\2\u0dbc\u0dc1\3\2\2\2\u0dbd\u0dc1\7\u00b3")
buf.write("\2\2\u0dbe\u0dc1\5\u02ac\u0157\2\u0dbf\u0dc1\5\u0292\u014a")
buf.write("\2\u0dc0\u0db6\3\2\2\2\u0dc0\u0db7\3\2\2\2\u0dc0\u0db8")
buf.write("\3\2\2\2\u0dc0\u0db9\3\2\2\2\u0dc0\u0dbd\3\2\2\2\u0dc0")
buf.write("\u0dbe\3\2\2\2\u0dc0\u0dbf\3\2\2\2\u0dc1\u0291\3\2\2\2")
buf.write("\u0dc2\u0dc3\7\u00ad\2\2\u0dc3\u0dc4\5\u0294\u014b\2\u0dc4")
buf.write("\u0dc5\7\u00af\2\2\u0dc5\u0293\3\2\2\2\u0dc6\u0dc9\5\u0272")
buf.write("\u013a\2\u0dc7\u0dc9\5\u0296\u014c\2\u0dc8\u0dc6\3\2\2")
buf.write("\2\u0dc8\u0dc7\3\2\2\2\u0dc9\u0295\3\2\2\2\u0dca\u0dcb")
buf.write("\b\u014c\1\2\u0dcb\u0dcc\5\u0272\u013a\2\u0dcc\u0dcd\7")
buf.write("|\2\2\u0dcd\u0dce\5\u0272\u013a\2\u0dce\u0dd5\3\2\2\2")
buf.write("\u0dcf\u0dd0\5\u0272\u013a\2\u0dd0\u0dd1\7|\2\2\u0dd1")
buf.write("\u0dd2\5\u0298\u014d\2\u0dd2\u0dd5\3\2\2\2\u0dd3\u0dd5")
buf.write("\5\u0298\u014d\2\u0dd4\u0dca\3\2\2\2\u0dd4\u0dcf\3\2\2")
buf.write("\2\u0dd4\u0dd3\3\2\2\2\u0dd5\u0dde\3\2\2\2\u0dd6\u0dd7")
buf.write("\f\4\2\2\u0dd7\u0dd8\7|\2\2\u0dd8\u0ddd\5\u0272\u013a")
buf.write("\2\u0dd9\u0dda\f\3\2\2\u0dda\u0ddb\7|\2\2\u0ddb\u0ddd")
buf.write("\5\u0298\u014d\2\u0ddc\u0dd6\3\2\2\2\u0ddc\u0dd9\3\2\2")
buf.write("\2\u0ddd\u0de0\3\2\2\2\u0dde\u0ddc\3\2\2\2\u0dde\u0ddf")
buf.write("\3\2\2\2\u0ddf\u0297\3\2\2\2\u0de0\u0dde\3\2\2\2\u0de1")
buf.write("\u0de2\7}\2\2\u0de2\u0de3\5\u0272\u013a\2\u0de3\u0de4")
buf.write("\7|\2\2\u0de4\u0de5\5\u01ac\u00d7\2\u0de5\u0de6\7\u0084")
buf.write("\2\2\u0de6\u0de7\5\u0272\u013a\2\u0de7\u0de8\7|\2\2\u0de8")
buf.write("\u0de9\5\u0272\u013a\2\u0de9\u0dea\7\u0082\2\2\u0dea\u0e0e")
buf.write("\3\2\2\2\u0deb\u0dec\7}\2\2\u0dec\u0ded\5\u0272\u013a")
buf.write("\2\u0ded\u0dee\7|\2\2\u0dee\u0def\5\u01ac\u00d7\2\u0def")
buf.write("\u0df0\7\u0084\2\2\u0df0\u0df1\5\u0272\u013a\2\u0df1\u0df2")
buf.write("\7|\2\2\u0df2\u0df3\5\u0272\u013a\2\u0df3\u0df4\7|\2\2")
buf.write("\u0df4\u0df5\5\u0272\u013a\2\u0df5\u0df6\7\u0082\2\2\u0df6")
buf.write("\u0e0e\3\2\2\2\u0df7\u0df8\7}\2\2\u0df8\u0df9\5\u0298")
buf.write("\u014d\2\u0df9\u0dfa\7|\2\2\u0dfa\u0dfb\5\u01ac\u00d7")
buf.write("\2\u0dfb\u0dfc\7\u0084\2\2\u0dfc\u0dfd\5\u0272\u013a\2")
buf.write("\u0dfd\u0dfe\7|\2\2\u0dfe\u0dff\5\u0272\u013a\2\u0dff")
buf.write("\u0e00\7\u0082\2\2\u0e00\u0e0e\3\2\2\2\u0e01\u0e02\7}")
buf.write("\2\2\u0e02\u0e03\5\u0298\u014d\2\u0e03\u0e04\7|\2\2\u0e04")
buf.write("\u0e05\5\u01ac\u00d7\2\u0e05\u0e06\7\u0084\2\2\u0e06\u0e07")
buf.write("\5\u0272\u013a\2\u0e07\u0e08\7|\2\2\u0e08\u0e09\5\u0272")
buf.write("\u013a\2\u0e09\u0e0a\7|\2\2\u0e0a\u0e0b\5\u0272\u013a")
buf.write("\2\u0e0b\u0e0c\7\u0082\2\2\u0e0c\u0e0e\3\2\2\2\u0e0d\u0de1")
buf.write("\3\2\2\2\u0e0d\u0deb\3\2\2\2\u0e0d\u0df7\3\2\2\2\u0e0d")
buf.write("\u0e01\3\2\2\2\u0e0e\u0299\3\2\2\2\u0e0f\u0e10\7\u00be")
buf.write("\2\2\u0e10\u0e11\7}\2\2\u0e11\u0e18\7\u0082\2\2\u0e12")
buf.write("\u0e13\7\u00be\2\2\u0e13\u0e14\7}\2\2\u0e14\u0e15\5\u029c")
buf.write("\u014f\2\u0e15\u0e16\7\u0082\2\2\u0e16\u0e18\3\2\2\2\u0e17")
buf.write("\u0e0f\3\2\2\2\u0e17\u0e12\3\2\2\2\u0e18\u029b\3\2\2\2")
buf.write("\u0e19\u0e1a\b\u014f\1\2\u0e1a\u0e20\5\u029e\u0150\2\u0e1b")
buf.write("\u0e1c\5\u02a6\u0154\2\u0e1c\u0e1d\7|\2\2\u0e1d\u0e1e")
buf.write("\5\u029e\u0150\2\u0e1e\u0e20\3\2\2\2\u0e1f\u0e19\3\2\2")
buf.write("\2\u0e1f\u0e1b\3\2\2\2\u0e20\u0e26\3\2\2\2\u0e21\u0e22")
buf.write("\f\4\2\2\u0e22\u0e23\7|\2\2\u0e23\u0e25\5\u029e\u0150")
buf.write("\2\u0e24\u0e21\3\2\2\2\u0e25\u0e28\3\2\2\2\u0e26\u0e24")
buf.write("\3\2\2\2\u0e26\u0e27\3\2\2\2\u0e27\u029d\3\2\2\2\u0e28")
buf.write("\u0e26\3\2\2\2\u0e29\u0e2a\7\u00be\2\2\u0e2a\u0e2b\7\u0084")
buf.write("\2\2\u0e2b\u0e2c\5\u0272\u013a\2\u0e2c\u029f\3\2\2\2\u0e2d")
buf.write("\u0e31\t\13\2\2\u0e2e\u0e30\5\u02a2\u0152\2\u0e2f\u0e2e")
buf.write("\3\2\2\2\u0e30\u0e33\3\2\2\2\u0e31\u0e2f\3\2\2\2\u0e31")
buf.write("\u0e32\3\2\2\2\u0e32\u02a1\3\2\2\2\u0e33\u0e31\3\2\2\2")
buf.write("\u0e34\u0e38\5\u02a4\u0153\2\u0e35\u0e36\7~\2\2\u0e36")
buf.write("\u0e38\7\u00be\2\2\u0e37\u0e34\3\2\2\2\u0e37\u0e35\3\2")
buf.write("\2\2\u0e38\u02a3\3\2\2\2\u0e39\u0e3a\7}\2\2\u0e3a\u0e3b")
buf.write("\5\u02a6\u0154\2\u0e3b\u0e3c\7\u0082\2\2\u0e3c\u02a5\3")
buf.write("\2\2\2\u0e3d\u0e42\5\u02a8\u0155\2\u0e3e\u0e3f\7|\2\2")
buf.write("\u0e3f\u0e41\5\u02a8\u0155\2\u0e40\u0e3e\3\2\2\2\u0e41")
buf.write("\u0e44\3\2\2\2\u0e42\u0e40\3\2\2\2\u0e42\u0e43\3\2\2\2")
buf.write("\u0e43\u02a7\3\2\2\2\u0e44\u0e42\3\2\2\2\u0e45\u0e47\5")
buf.write("\u0272\u013a\2\u0e46\u0e48\5\u02aa\u0156\2\u0e47\u0e46")
buf.write("\3\2\2\2\u0e47\u0e48\3\2\2\2\u0e48\u0e4b\3\2\2\2\u0e49")
buf.write("\u0e4b\5\u02aa\u0156\2\u0e4a\u0e45\3\2\2\2\u0e4a\u0e49")
buf.write("\3\2\2\2\u0e4b\u02a9\3\2\2\2\u0e4c\u0e4e\7\u0083\2\2\u0e4d")
buf.write("\u0e4f\5\u0272\u013a\2\u0e4e\u0e4d\3\2\2\2\u0e4e\u0e4f")
buf.write("\3\2\2\2\u0e4f\u0e58\3\2\2\2\u0e50\u0e51\7\u0083\2\2\u0e51")
buf.write("\u0e52\5\u0272\u013a\2\u0e52\u0e53\7\u0083\2\2\u0e53\u0e54")
buf.write("\5\u0272\u013a\2\u0e54\u0e58\3\2\2\2\u0e55\u0e56\7 \2")
buf.write("\2\u0e56\u0e58\5\u0272\u013a\2\u0e57\u0e4c\3\2\2\2\u0e57")
buf.write("\u0e50\3\2\2\2\u0e57\u0e55\3\2\2\2\u0e58\u02ab\3\2\2\2")
buf.write("\u0e59\u0e63\t\f\2\2\u0e5a\u0e5b\7\u0097\2\2\u0e5b\u0e5c")
buf.write("\7\u00ac\2\2\u0e5c\u0e63\5\u02ae\u0158\2\u0e5d\u0e5e\7")
buf.write("\u0098\2\2\u0e5e\u0e5f\7\u00ac\2\2\u0e5f\u0e60\5\u02ae")
buf.write("\u0158\2\u0e60\u0e61\7\u00ae\2\2\u0e61\u0e63\3\2\2\2\u0e62")
buf.write("\u0e59\3\2\2\2\u0e62\u0e5a\3\2\2\2\u0e62\u0e5d\3\2\2\2")
buf.write("\u0e63\u02ad\3\2\2\2\u0e64\u0e67\7\u00bc\2\2\u0e65\u0e67")
buf.write("\5\u0126\u0094\2\u0e66\u0e64\3\2\2\2\u0e66\u0e65\3\2\2")
buf.write("\2\u0e67\u02af\3\2\2\2\u0e68\u0e71\t\r\2\2\u0e69\u0e71")
buf.write("\5\u02b2\u015a\2\u0e6a\u0e6b\7\u00bc\2\2\u0e6b\u0e6c\7")
buf.write("\u00ac\2\2\u0e6c\u0e71\5\u02ae\u0158\2\u0e6d\u0e6e\7\u00b4")
buf.write("\2\2\u0e6e\u0e6f\7\u00ac\2\2\u0e6f\u0e71\5\u02ae\u0158")
buf.write("\2\u0e70\u0e68\3\2\2\2\u0e70\u0e69\3\2\2\2\u0e70\u0e6a")
buf.write("\3\2\2\2\u0e70\u0e6d\3\2\2\2\u0e71\u02b1\3\2\2\2\u0e72")
buf.write("\u0e73\7}\2\2\u0e73\u0e74\5\u02b4\u015b\2\u0e74\u0e75")
buf.write("\7|\2\2\u0e75\u0e76\7\u0082\2\2\u0e76\u02b3\3\2\2\2\u0e77")
buf.write("\u0e79\t\3\2\2\u0e78\u0e77\3\2\2\2\u0e78\u0e79\3\2\2\2")
buf.write("\u0e79\u0e7a\3\2\2\2\u0e7a\u0e7e\7\u00bc\2\2\u0e7b\u0e7e")
buf.write("\7\u00b4\2\2\u0e7c\u0e7e\7\u00be\2\2\u0e7d\u0e78\3\2\2")
buf.write("\2\u0e7d\u0e7b\3\2\2\2\u0e7d\u0e7c\3\2\2\2\u0e7e\u02b5")
buf.write("\3\2\2\2\u0e7f\u0e80\5\u0272\u013a\2\u0e80\u02b7\3\2\2")
buf.write("\2\u0e81\u0e82\7\65\2\2\u0e82\u0e83\7}\2\2\u0e83\u0e84")
buf.write("\5\u0272\u013a\2\u0e84\u0e85\7\u0082\2\2\u0e85\u0e86\5")
buf.write("\u01b6\u00dc\2\u0e86\u02b9\3\2\2\2\u014d\u02bf\u02c6\u02c9")
buf.write("\u02d1\u02d7\u02e1\u02e7\u02ec\u02f5\u0308\u030f\u0318")
buf.write("\u031f\u0330\u033a\u033c\u0345\u0349\u034e\u0350\u0359")
buf.write("\u0360\u0365\u036a\u0370\u0373\u0379\u0382\u0393\u0395")
buf.write("\u03a2\u03ad\u03b7\u03c0\u03c5\u03c9\u03cc\u03d8\u03db")
buf.write("\u03e2\u03e7\u03ed\u03fd\u0401\u040a\u0413\u0417\u0420")
buf.write("\u0429\u042d\u0436\u0454\u0456\u0462\u0472\u047b\u0484")
buf.write("\u048a\u048e\u0495\u049a\u04a4\u04a9\u04ad\u04b9\u04c3")
buf.write("\u04cd\u04da\u04e1\u04e6\u04ed\u04f4\u04fb\u04fd\u0502")
buf.write("\u0511\u051a\u051f\u052a\u0540\u0547\u0575\u057d\u0588")
buf.write("\u058f\u0596\u05a7\u05b0\u05b3\u05ba\u05c5\u05d4\u05dd")
buf.write("\u05e2\u05ed\u05f9\u05fd\u0605\u0607\u060c\u060f\u0616")
buf.write("\u061a\u0620\u0629\u0635\u063c\u063e\u064c\u0658\u0661")
buf.write("\u0666\u0677\u067e\u06ac\u06b5\u06be\u06c2\u06c9\u06d1")
buf.write("\u06dc\u06fa\u0706\u072c\u0734\u073b\u073f\u074e\u075f")
buf.write("\u076b\u0771\u0773\u0778\u077e\u0788\u0792\u07a2\u07a7")
buf.write("\u07ab\u07b2\u07ba\u07c4\u07cc\u07d5\u07fd\u0803\u0807")
buf.write("\u080c\u080e\u0817\u081c\u0824\u082b\u0830\u083c\u0843")
buf.write("\u0847\u0854\u0867\u0871\u0875\u0878\u087c\u0881\u0888")
buf.write("\u088d\u088f\u089c\u08ad\u08b6\u08bb\u08c6\u08d0\u08de")
buf.write("\u08e2\u08e6\u08e9\u08f2\u08f8\u0913\u0918\u091d\u0927")
buf.write("\u0932\u093e\u0943\u094d\u0954\u0978\u0985\u098c\u099a")
buf.write("\u099f\u09a4\u09ad\u09b2\u09c2\u09c9\u09ce\u09de\u09e5")
buf.write("\u09ec\u09f5\u09fe\u0a05\u0a15\u0a1c\u0a24\u0a2f\u0a36")
buf.write("\u0a3f\u0a44\u0a49\u0a4b\u0a61\u0a6c\u0a71\u0a7c\u0a85")
buf.write("\u0a8e\u0a9a\u0aa1\u0ac2\u0acb\u0acf\u0adb\u0ae3\u0ae5")
buf.write("\u0af1\u0afe\u0b02\u0b07\u0b0b\u0b13\u0b16\u0b1c\u0b46")
buf.write("\u0b55\u0b58\u0b5b\u0b61\u0baf\u0bb4\u0bba\u0bc4\u0bcb")
buf.write("\u0bd3\u0bdc\u0be5\u0beb\u0bf1\u0bf7\u0c01\u0c04\u0c0a")
buf.write("\u0c18\u0c1e\u0c26\u0c2b\u0c3b\u0c40\u0c46\u0c57\u0c68")
buf.write("\u0c6c\u0c6f\u0c75\u0c85\u0c8c\u0c93\u0c96\u0c9a\u0c9d")
buf.write("\u0ca5\u0ca9\u0cba\u0cbe\u0cc1\u0cc6\u0cca\u0cd5\u0cd9")
buf.write("\u0cdf\u0ce6\u0cf4\u0cf6\u0cfe\u0d08\u0d13\u0d19\u0d21")
buf.write("\u0d2a\u0d31\u0d3c\u0d3f\u0d45\u0d55\u0d5f\u0d67\u0d6f")
buf.write("\u0d73\u0d7f\u0d85\u0d89\u0d8e\u0d92\u0d99\u0da3\u0dab")
buf.write("\u0db2\u0dc0\u0dc8\u0dd4\u0ddc\u0dde\u0e0d\u0e17\u0e1f")
buf.write("\u0e26\u0e31\u0e37\u0e42\u0e47\u0e4a\u0e4e\u0e57\u0e62")
buf.write("\u0e66\u0e70\u0e78\u0e7d")
return buf.getvalue()
[docs]
class Fortran90Parser ( Parser ):
grammarFileName = "Fortran90Parser.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>", "<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>", "'CCON'", "'HOLLERITH'",
"'CONCATOP'", "'CTRLDIRECT'", "'CTRLREC'", "'TO'",
"'SUBPROGRAMBLOCK'", "'DOBLOCK'", "'AIF'", "'THENBLOCK'",
"'ELSEBLOCK'", "'CODEROOT'", "<INVALID>", "<INVALID>",
"<INVALID>", "<INVALID>", "<INVALID>", "'(/'", "'.'",
"'/)'", "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
"<INVALID>", "<INVALID>", "'SPOFF'", "'SPON'" ]
symbolicNames = [ "<INVALID>", "RECURSIVE", "CONTAINS", "MODULE", "ENDMODULE",
"PROGRAM", "ENTRY", "FUNCTION", "BLOCK", "SUBROUTINE",
"ENDINTERFACE", "PROCEDURE", "END", "DIMENSION", "TARGET",
"ALLOCATABLE", "OPTIONAL", "NAMELIST", "INTENT", "IN",
"OUT", "INOUT", "OPERATOR", "USE", "ONLY", "IMPLIEDT",
"ASSIGNMENT", "DOP", "OP", "DOUBLEPRECISION", "DOUBLECOLON",
"ASSIGNSTMT", "COMMON", "ELSEWHERE", "REAL", "EQUIVALENCE",
"BLOCKDATA", "POINTER", "PRIVATE", "SEQUENCE", "ACCESSSPEC",
"IMPLICIT", "NONE", "CHARACTER", "PARAMETER", "EXTERNAL",
"INTRINSIC", "SAVE", "DATA", "GO", "GOTO", "IF", "THEN",
"ELSE", "ENDIF", "RESULT", "ELSEIF", "DO", "INCLUDE",
"CONTINUE", "ENDWHERE", "WHERE", "ENDSELECT", "SELECTCASE",
"SELECT", "CASE", "DEFAULT", "DIRECT", "STOP", "REC",
"ENDDO", "PAUSE", "WRITE", "READ", "PRINT", "OPEN",
"FMT", "UNIT", "PAD", "ACTION", "DELIM", "IOLENGTH",
"READWRITE", "ERR", "SIZE", "ADVANCE", "NML", "IOSTAT",
"FORMAT", "LET", "CALL", "RETURN", "CLOSE", "DOUBLE",
"IOSTART", "SEQUENTIAL", "LABEL", "FILE", "STATUS",
"ACCESS", "POSITION", "FORM", "RECL", "EXIST", "OPENED",
"NUMBER", "NAMED", "NAME_", "FORMATTED", "UNFORMATTED",
"NEXTREC", "INQUIRE", "BACKSPACE", "ENDFILE", "REWIND",
"ENDBLOCKDATA", "ENDBLOCK", "KIND", "LEN", "WS", "COMMENT",
"DOLLAR", "COMMA", "LPAREN", "PCT", "WHILE", "ALLOCATE",
"STAT", "RPAREN", "COLON", "ASSIGN", "MINUS", "PLUS",
"DIV", "FORMATSEP", "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", "UNDERSCORE", "OBRACKETSLASH", "DOT", "CBRACKETSLASH",
"ZCON", "BCON", "OCON", "SCON", "RDCON", "DEALLOCATE",
"NULLIFY", "CYCLE", "ENDTYPE", "INTERFACE", "SPOFF",
"SPON", "ICON", "TYPE", "NAME", "EXIT", "BLANK", "ALPHANUMERIC_CHARACTER",
"STAR", "STRINGLITERAL", "EOL", "LINECONT" ]
RULE_program = 0
RULE_executableProgram = 1
RULE_programUnit = 2
RULE_mainProgram = 3
RULE_programStmt = 4
RULE_mainRange = 5
RULE_bodyPlusInternals = 6
RULE_internalSubprogram = 7
RULE_specificationPartConstruct = 8
RULE_useStmt = 9
RULE_onlyList = 10
RULE_onlyStmt = 11
RULE_renameList = 12
RULE_rename = 13
RULE_useName = 14
RULE_parameterStmt = 15
RULE_namedConstantDefList = 16
RULE_namedConstantDef = 17
RULE_endProgramStmt = 18
RULE_blockDataSubprogram = 19
RULE_blockDataStmt = 20
RULE_blockDataBody = 21
RULE_blockDataBodyConstruct = 22
RULE_endBlockDataStmt = 23
RULE_formatStmt = 24
RULE_fmtSpec = 25
RULE_formatedit = 26
RULE_editElement = 27
RULE_mislexedFcon = 28
RULE_module = 29
RULE_endModuleStmt = 30
RULE_entryStmt = 31
RULE_subroutineParList = 32
RULE_subroutinePars = 33
RULE_subroutinePar = 34
RULE_declarationConstruct = 35
RULE_specificationStmt = 36
RULE_targetStmt = 37
RULE_targetObjectList = 38
RULE_targetObject = 39
RULE_pointerStmt = 40
RULE_pointerStmtObjectList = 41
RULE_pointerStmtObject = 42
RULE_optionalStmt = 43
RULE_optionalParList = 44
RULE_optionalPar = 45
RULE_namelistStmt = 46
RULE_namelistGroups = 47
RULE_namelistGroupName = 48
RULE_namelistGroupObject = 49
RULE_intentStmt = 50
RULE_intentParList = 51
RULE_intentPar = 52
RULE_dummyArgName = 53
RULE_intentSpec = 54
RULE_allocatableStmt = 55
RULE_arrayAllocationList = 56
RULE_arrayAllocation = 57
RULE_arrayName = 58
RULE_accessStmt = 59
RULE_accessIdList = 60
RULE_accessId = 61
RULE_genericName = 62
RULE_saveStmt = 63
RULE_savedEntityList = 64
RULE_savedEntity = 65
RULE_savedCommonBlock = 66
RULE_intrinsicStmt = 67
RULE_intrinsicList = 68
RULE_intrinsicProcedureName = 69
RULE_externalStmt = 70
RULE_externalNameList = 71
RULE_externalName = 72
RULE_equivalenceStmt = 73
RULE_equivalenceSetList = 74
RULE_equivalenceSet = 75
RULE_equivalenceObject = 76
RULE_equivalenceObjectList = 77
RULE_dimensionStmt = 78
RULE_arrayDeclaratorList = 79
RULE_commonStmt = 80
RULE_comlist = 81
RULE_commonBlockObject = 82
RULE_arrayDeclarator = 83
RULE_comblock = 84
RULE_commonBlockName = 85
RULE_typeDeclarationStmt = 86
RULE_attrSpecSeq = 87
RULE_attrSpec = 88
RULE_entityDeclList = 89
RULE_entityDecl = 90
RULE_objectName = 91
RULE_arraySpec = 92
RULE_assumedShapeSpecList = 93
RULE_assumedShapeSpec = 94
RULE_assumedSizeSpec = 95
RULE_interfaceBlock = 96
RULE_endInterfaceStmt = 97
RULE_interfaceStmt = 98
RULE_genericSpec = 99
RULE_definedOperator = 100
RULE_interfaceBlockBody = 101
RULE_interfaceBodyPartConstruct = 102
RULE_moduleProcedureStmt = 103
RULE_procedureNameList = 104
RULE_procedureName = 105
RULE_interfaceBody = 106
RULE_subroutineInterfaceRange = 107
RULE_endSubroutineStmt = 108
RULE_recursive = 109
RULE_functionPrefix = 110
RULE_functionInterfaceRange = 111
RULE_functionParList = 112
RULE_functionPars = 113
RULE_functionPar = 114
RULE_subprogramInterfaceBody = 115
RULE_endFunctionStmt = 116
RULE_derivedTypeDef = 117
RULE_endTypeStmt = 118
RULE_derivedTypeStmt = 119
RULE_derivedTypeBody = 120
RULE_derivedTypeBodyConstruct = 121
RULE_privateSequenceStmt = 122
RULE_componentDefStmt = 123
RULE_componentDeclList = 124
RULE_componentDecl = 125
RULE_componentName = 126
RULE_componentAttrSpecList = 127
RULE_componentAttrSpec = 128
RULE_componentArraySpec = 129
RULE_explicitShapeSpecList = 130
RULE_explicitShapeSpec = 131
RULE_lowerBound = 132
RULE_upperBound = 133
RULE_deferredShapeSpecList = 134
RULE_deferredShapeSpec = 135
RULE_typeSpec = 136
RULE_kindSelector = 137
RULE_typeName = 138
RULE_charSelector = 139
RULE_lengthSelector = 140
RULE_charLength = 141
RULE_constant = 142
RULE_bozLiteralConstant = 143
RULE_structureConstructor = 144
RULE_exprList = 145
RULE_namedConstantUse = 146
RULE_typeParamValue = 147
RULE_moduleStmt = 148
RULE_moduleName = 149
RULE_ident = 150
RULE_moduleBody = 151
RULE_moduleSubprogramPartConstruct = 152
RULE_containsStmt = 153
RULE_moduleSubprogram = 154
RULE_functionSubprogram = 155
RULE_functionName = 156
RULE_functionRange = 157
RULE_body = 158
RULE_bodyConstruct = 159
RULE_executableConstruct = 160
RULE_whereConstruct = 161
RULE_elseWhere = 162
RULE_elsewhereStmt = 163
RULE_endWhereStmt = 164
RULE_where = 165
RULE_whereConstructStmt = 166
RULE_maskExpr = 167
RULE_caseConstruct = 168
RULE_selectCaseRange = 169
RULE_endSelectStmt = 170
RULE_selectCaseBody = 171
RULE_caseBodyConstruct = 172
RULE_caseStmt = 173
RULE_caseSelector = 174
RULE_caseValueRangeList = 175
RULE_caseValueRange = 176
RULE_ifConstruct = 177
RULE_ifThenStmt = 178
RULE_conditionalBody = 179
RULE_elseIfConstruct = 180
RULE_elseIfStmt = 181
RULE_elseConstruct = 182
RULE_elseStmt = 183
RULE_endIfStmt = 184
RULE_doConstruct = 185
RULE_blockDoConstruct = 186
RULE_endDoStmt = 187
RULE_endName = 188
RULE_nameColon = 189
RULE_labelDoStmt = 190
RULE_doLblRef = 191
RULE_doLblDef = 192
RULE_doLabelStmt = 193
RULE_executionPartConstruct = 194
RULE_doubleDoStmt = 195
RULE_dataStmt = 196
RULE_dataStmtSet = 197
RULE_dse1 = 198
RULE_dse2 = 199
RULE_dataStmtValue = 200
RULE_dataStmtObject = 201
RULE_variable = 202
RULE_subscriptListRef = 203
RULE_subscriptList = 204
RULE_subscript = 205
RULE_substringRange = 206
RULE_dataImpliedDo = 207
RULE_dataIDoObjectList = 208
RULE_dataIDoObject = 209
RULE_structureComponent = 210
RULE_fieldSelector = 211
RULE_arrayElement = 212
RULE_impliedDoVariable = 213
RULE_commaLoopControl = 214
RULE_loopControl = 215
RULE_variableName = 216
RULE_commaExpr = 217
RULE_actionStmt = 218
RULE_whereStmt = 219
RULE_pointerAssignmentStmt = 220
RULE_target = 221
RULE_nullifyStmt = 222
RULE_pointerObjectList = 223
RULE_pointerObject = 224
RULE_pointerField = 225
RULE_exitStmt = 226
RULE_deallocateStmt = 227
RULE_allocateObjectList = 228
RULE_cycleStmt = 229
RULE_allocateStmt = 230
RULE_allocationList = 231
RULE_allocation = 232
RULE_allocateObject = 233
RULE_allocatedShape = 234
RULE_stopStmt = 235
RULE_writeStmt = 236
RULE_ioControlSpecList = 237
RULE_stmtFunctionStmt = 238
RULE_stmtFunctionRange = 239
RULE_sFDummyArgNameList = 240
RULE_sFDummyArgName = 241
RULE_returnStmt = 242
RULE_rewindStmt = 243
RULE_readStmt = 244
RULE_commaInputItemList = 245
RULE_rdFmtId = 246
RULE_rdFmtIdExpr = 247
RULE_inputItemList = 248
RULE_inputItem = 249
RULE_inputImpliedDo = 250
RULE_rdCtlSpec = 251
RULE_rdUnitId = 252
RULE_rdIoCtlSpecList = 253
RULE_ioControlSpec = 254
RULE_printStmt = 255
RULE_outputItemList = 256
RULE_outputItemList1 = 257
RULE_outputImpliedDo = 258
RULE_formatIdentifier = 259
RULE_pauseStmt = 260
RULE_openStmt = 261
RULE_connectSpecList = 262
RULE_connectSpec = 263
RULE_inquireStmt = 264
RULE_inquireSpecList = 265
RULE_inquireSpec = 266
RULE_assignedGotoStmt = 267
RULE_variableComma = 268
RULE_gotoStmt = 269
RULE_computedGotoStmt = 270
RULE_lblRefList = 271
RULE_endfileStmt = 272
RULE_continueStmt = 273
RULE_closeStmt = 274
RULE_closeSpecList = 275
RULE_closeSpec = 276
RULE_cExpression = 277
RULE_cPrimary = 278
RULE_cOperand = 279
RULE_cPrimaryConcatOp = 280
RULE_callStmt = 281
RULE_subroutineNameUse = 282
RULE_subroutineArgList = 283
RULE_subroutineArg = 284
RULE_arithmeticIfStmt = 285
RULE_lblRef = 286
RULE_label = 287
RULE_assignmentStmt = 288
RULE_sFExprListRef = 289
RULE_sFExprList = 290
RULE_commaSectionSubscript = 291
RULE_assignStmt = 292
RULE_backspaceStmt = 293
RULE_unitIdentifier = 294
RULE_positionSpecList = 295
RULE_unitIdentifierComma = 296
RULE_positionSpec = 297
RULE_scalarVariable = 298
RULE_uFExpr = 299
RULE_uFTerm = 300
RULE_uFFactor = 301
RULE_uFPrimary = 302
RULE_subroutineSubprogram = 303
RULE_subroutineName = 304
RULE_subroutineRange = 305
RULE_includeStmt = 306
RULE_implicitStmt = 307
RULE_implicitSpecList = 308
RULE_implicitSpec = 309
RULE_implicitRanges = 310
RULE_implicitRange = 311
RULE_expression = 312
RULE_definedBinaryOp = 313
RULE_level5Expr = 314
RULE_equivOperand = 315
RULE_orOperand = 316
RULE_andOperand = 317
RULE_relOp = 318
RULE_level4Expr = 319
RULE_level3Expr = 320
RULE_level2Expr = 321
RULE_sign = 322
RULE_addOperand = 323
RULE_multOperand = 324
RULE_level1Expr = 325
RULE_definedUnaryOp = 326
RULE_primary = 327
RULE_arrayConstructor = 328
RULE_acValueList = 329
RULE_acValueList1 = 330
RULE_acImpliedDo = 331
RULE_functionReference = 332
RULE_functionArgList = 333
RULE_functionArg = 334
RULE_nameDataRef = 335
RULE_complexDataRefTail = 336
RULE_sectionSubscriptRef = 337
RULE_sectionSubscriptList = 338
RULE_sectionSubscript = 339
RULE_subscriptTripletTail = 340
RULE_logicalConstant = 341
RULE_kindParam = 342
RULE_unsignedArithmeticConstant = 343
RULE_complexConst = 344
RULE_complexComponent = 345
RULE_constantExpr = 346
RULE_ifStmt = 347
ruleNames = [ "program", "executableProgram", "programUnit", "mainProgram",
"programStmt", "mainRange", "bodyPlusInternals", "internalSubprogram",
"specificationPartConstruct", "useStmt", "onlyList",
"onlyStmt", "renameList", "rename", "useName", "parameterStmt",
"namedConstantDefList", "namedConstantDef", "endProgramStmt",
"blockDataSubprogram", "blockDataStmt", "blockDataBody",
"blockDataBodyConstruct", "endBlockDataStmt", "formatStmt",
"fmtSpec", "formatedit", "editElement", "mislexedFcon",
"module", "endModuleStmt", "entryStmt", "subroutineParList",
"subroutinePars", "subroutinePar", "declarationConstruct",
"specificationStmt", "targetStmt", "targetObjectList",
"targetObject", "pointerStmt", "pointerStmtObjectList",
"pointerStmtObject", "optionalStmt", "optionalParList",
"optionalPar", "namelistStmt", "namelistGroups", "namelistGroupName",
"namelistGroupObject", "intentStmt", "intentParList",
"intentPar", "dummyArgName", "intentSpec", "allocatableStmt",
"arrayAllocationList", "arrayAllocation", "arrayName",
"accessStmt", "accessIdList", "accessId", "genericName",
"saveStmt", "savedEntityList", "savedEntity", "savedCommonBlock",
"intrinsicStmt", "intrinsicList", "intrinsicProcedureName",
"externalStmt", "externalNameList", "externalName", "equivalenceStmt",
"equivalenceSetList", "equivalenceSet", "equivalenceObject",
"equivalenceObjectList", "dimensionStmt", "arrayDeclaratorList",
"commonStmt", "comlist", "commonBlockObject", "arrayDeclarator",
"comblock", "commonBlockName", "typeDeclarationStmt",
"attrSpecSeq", "attrSpec", "entityDeclList", "entityDecl",
"objectName", "arraySpec", "assumedShapeSpecList", "assumedShapeSpec",
"assumedSizeSpec", "interfaceBlock", "endInterfaceStmt",
"interfaceStmt", "genericSpec", "definedOperator", "interfaceBlockBody",
"interfaceBodyPartConstruct", "moduleProcedureStmt",
"procedureNameList", "procedureName", "interfaceBody",
"subroutineInterfaceRange", "endSubroutineStmt", "recursive",
"functionPrefix", "functionInterfaceRange", "functionParList",
"functionPars", "functionPar", "subprogramInterfaceBody",
"endFunctionStmt", "derivedTypeDef", "endTypeStmt", "derivedTypeStmt",
"derivedTypeBody", "derivedTypeBodyConstruct", "privateSequenceStmt",
"componentDefStmt", "componentDeclList", "componentDecl",
"componentName", "componentAttrSpecList", "componentAttrSpec",
"componentArraySpec", "explicitShapeSpecList", "explicitShapeSpec",
"lowerBound", "upperBound", "deferredShapeSpecList",
"deferredShapeSpec", "typeSpec", "kindSelector", "typeName",
"charSelector", "lengthSelector", "charLength", "constant",
"bozLiteralConstant", "structureConstructor", "exprList",
"namedConstantUse", "typeParamValue", "moduleStmt", "moduleName",
"ident", "moduleBody", "moduleSubprogramPartConstruct",
"containsStmt", "moduleSubprogram", "functionSubprogram",
"functionName", "functionRange", "body", "bodyConstruct",
"executableConstruct", "whereConstruct", "elseWhere",
"elsewhereStmt", "endWhereStmt", "where", "whereConstructStmt",
"maskExpr", "caseConstruct", "selectCaseRange", "endSelectStmt",
"selectCaseBody", "caseBodyConstruct", "caseStmt", "caseSelector",
"caseValueRangeList", "caseValueRange", "ifConstruct",
"ifThenStmt", "conditionalBody", "elseIfConstruct", "elseIfStmt",
"elseConstruct", "elseStmt", "endIfStmt", "doConstruct",
"blockDoConstruct", "endDoStmt", "endName", "nameColon",
"labelDoStmt", "doLblRef", "doLblDef", "doLabelStmt",
"executionPartConstruct", "doubleDoStmt", "dataStmt",
"dataStmtSet", "dse1", "dse2", "dataStmtValue", "dataStmtObject",
"variable", "subscriptListRef", "subscriptList", "subscript",
"substringRange", "dataImpliedDo", "dataIDoObjectList",
"dataIDoObject", "structureComponent", "fieldSelector",
"arrayElement", "impliedDoVariable", "commaLoopControl",
"loopControl", "variableName", "commaExpr", "actionStmt",
"whereStmt", "pointerAssignmentStmt", "target", "nullifyStmt",
"pointerObjectList", "pointerObject", "pointerField",
"exitStmt", "deallocateStmt", "allocateObjectList", "cycleStmt",
"allocateStmt", "allocationList", "allocation", "allocateObject",
"allocatedShape", "stopStmt", "writeStmt", "ioControlSpecList",
"stmtFunctionStmt", "stmtFunctionRange", "sFDummyArgNameList",
"sFDummyArgName", "returnStmt", "rewindStmt", "readStmt",
"commaInputItemList", "rdFmtId", "rdFmtIdExpr", "inputItemList",
"inputItem", "inputImpliedDo", "rdCtlSpec", "rdUnitId",
"rdIoCtlSpecList", "ioControlSpec", "printStmt", "outputItemList",
"outputItemList1", "outputImpliedDo", "formatIdentifier",
"pauseStmt", "openStmt", "connectSpecList", "connectSpec",
"inquireStmt", "inquireSpecList", "inquireSpec", "assignedGotoStmt",
"variableComma", "gotoStmt", "computedGotoStmt", "lblRefList",
"endfileStmt", "continueStmt", "closeStmt", "closeSpecList",
"closeSpec", "cExpression", "cPrimary", "cOperand", "cPrimaryConcatOp",
"callStmt", "subroutineNameUse", "subroutineArgList",
"subroutineArg", "arithmeticIfStmt", "lblRef", "label",
"assignmentStmt", "sFExprListRef", "sFExprList", "commaSectionSubscript",
"assignStmt", "backspaceStmt", "unitIdentifier", "positionSpecList",
"unitIdentifierComma", "positionSpec", "scalarVariable",
"uFExpr", "uFTerm", "uFFactor", "uFPrimary", "subroutineSubprogram",
"subroutineName", "subroutineRange", "includeStmt", "implicitStmt",
"implicitSpecList", "implicitSpec", "implicitRanges",
"implicitRange", "expression", "definedBinaryOp", "level5Expr",
"equivOperand", "orOperand", "andOperand", "relOp", "level4Expr",
"level3Expr", "level2Expr", "sign", "addOperand", "multOperand",
"level1Expr", "definedUnaryOp", "primary", "arrayConstructor",
"acValueList", "acValueList1", "acImpliedDo", "functionReference",
"functionArgList", "functionArg", "nameDataRef", "complexDataRefTail",
"sectionSubscriptRef", "sectionSubscriptList", "sectionSubscript",
"subscriptTripletTail", "logicalConstant", "kindParam",
"unsignedArithmeticConstant", "complexConst", "complexComponent",
"constantExpr", "ifStmt" ]
EOF = Token.EOF
RECURSIVE=1
CONTAINS=2
MODULE=3
ENDMODULE=4
PROGRAM=5
ENTRY=6
FUNCTION=7
BLOCK=8
SUBROUTINE=9
ENDINTERFACE=10
PROCEDURE=11
END=12
DIMENSION=13
TARGET=14
ALLOCATABLE=15
OPTIONAL=16
NAMELIST=17
INTENT=18
IN=19
OUT=20
INOUT=21
OPERATOR=22
USE=23
ONLY=24
IMPLIEDT=25
ASSIGNMENT=26
DOP=27
OP=28
DOUBLEPRECISION=29
DOUBLECOLON=30
ASSIGNSTMT=31
COMMON=32
ELSEWHERE=33
REAL=34
EQUIVALENCE=35
BLOCKDATA=36
POINTER=37
PRIVATE=38
SEQUENCE=39
ACCESSSPEC=40
IMPLICIT=41
NONE=42
CHARACTER=43
PARAMETER=44
EXTERNAL=45
INTRINSIC=46
SAVE=47
DATA=48
GO=49
GOTO=50
IF=51
THEN=52
ELSE=53
ENDIF=54
RESULT=55
ELSEIF=56
DO=57
INCLUDE=58
CONTINUE=59
ENDWHERE=60
WHERE=61
ENDSELECT=62
SELECTCASE=63
SELECT=64
CASE=65
DEFAULT=66
DIRECT=67
STOP=68
REC=69
ENDDO=70
PAUSE=71
WRITE=72
READ=73
PRINT=74
OPEN=75
FMT=76
UNIT=77
PAD=78
ACTION=79
DELIM=80
IOLENGTH=81
READWRITE=82
ERR=83
SIZE=84
ADVANCE=85
NML=86
IOSTAT=87
FORMAT=88
LET=89
CALL=90
RETURN=91
CLOSE=92
DOUBLE=93
IOSTART=94
SEQUENTIAL=95
LABEL=96
FILE=97
STATUS=98
ACCESS=99
POSITION=100
FORM=101
RECL=102
EXIST=103
OPENED=104
NUMBER=105
NAMED=106
NAME_=107
FORMATTED=108
UNFORMATTED=109
NEXTREC=110
INQUIRE=111
BACKSPACE=112
ENDFILE=113
REWIND=114
ENDBLOCKDATA=115
ENDBLOCK=116
KIND=117
LEN=118
WS=119
COMMENT=120
DOLLAR=121
COMMA=122
LPAREN=123
PCT=124
WHILE=125
ALLOCATE=126
STAT=127
RPAREN=128
COLON=129
ASSIGN=130
MINUS=131
PLUS=132
DIV=133
FORMATSEP=134
POWER=135
LNOT=136
LAND=137
LOR=138
EQV=139
NEQV=140
XOR=141
EOR=142
LT=143
LE=144
GT=145
GE=146
NE=147
EQ=148
TRUE=149
FALSE=150
XCON=151
PCON=152
FCON=153
CCON=154
HOLLERITH=155
CONCATOP=156
CTRLDIRECT=157
CTRLREC=158
TO=159
SUBPROGRAMBLOCK=160
DOBLOCK=161
AIF=162
THENBLOCK=163
ELSEBLOCK=164
CODEROOT=165
COMPLEX=166
PRECISION=167
INTEGER=168
LOGICAL=169
UNDERSCORE=170
OBRACKETSLASH=171
DOT=172
CBRACKETSLASH=173
ZCON=174
BCON=175
OCON=176
SCON=177
RDCON=178
DEALLOCATE=179
NULLIFY=180
CYCLE=181
ENDTYPE=182
INTERFACE=183
SPOFF=184
SPON=185
ICON=186
TYPE=187
NAME=188
EXIT=189
BLANK=190
ALPHANUMERIC_CHARACTER=191
STAR=192
STRINGLITERAL=193
EOL=194
LINECONT=195
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 executableProgram(self):
return self.getTypedRuleContext(Fortran90Parser.ExecutableProgramContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.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 = Fortran90Parser.ProgramContext(self, self._ctx, self.state)
self.enterRule(localctx, 0, self.RULE_program)
try:
self.enterOuterAlt(localctx, 1)
self.state = 696
self.executableProgram()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ExecutableProgramContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def programUnit(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.ProgramUnitContext)
else:
return self.getTypedRuleContext(Fortran90Parser.ProgramUnitContext,i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_executableProgram
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterExecutableProgram" ):
listener.enterExecutableProgram(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitExecutableProgram" ):
listener.exitExecutableProgram(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitExecutableProgram" ):
return visitor.visitExecutableProgram(self)
else:
return visitor.visitChildren(self)
[docs]
def executableProgram(self):
localctx = Fortran90Parser.ExecutableProgramContext(self, self._ctx, self.state)
self.enterRule(localctx, 2, self.RULE_executableProgram)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 699
self._errHandler.sync(self)
_la = self._input.LA(1)
while True:
self.state = 698
self.programUnit()
self.state = 701
self._errHandler.sync(self)
_la = self._input.LA(1)
if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Fortran90Parser.RECURSIVE) | (1 << Fortran90Parser.CONTAINS) | (1 << Fortran90Parser.MODULE) | (1 << Fortran90Parser.PROGRAM) | (1 << Fortran90Parser.ENTRY) | (1 << Fortran90Parser.FUNCTION) | (1 << Fortran90Parser.BLOCK) | (1 << Fortran90Parser.SUBROUTINE) | (1 << Fortran90Parser.END) | (1 << Fortran90Parser.DIMENSION) | (1 << Fortran90Parser.TARGET) | (1 << Fortran90Parser.ALLOCATABLE) | (1 << Fortran90Parser.OPTIONAL) | (1 << Fortran90Parser.NAMELIST) | (1 << Fortran90Parser.INTENT) | (1 << Fortran90Parser.USE) | (1 << Fortran90Parser.DOUBLEPRECISION) | (1 << Fortran90Parser.ASSIGNSTMT) | (1 << Fortran90Parser.COMMON) | (1 << Fortran90Parser.REAL) | (1 << Fortran90Parser.EQUIVALENCE) | (1 << Fortran90Parser.BLOCKDATA) | (1 << Fortran90Parser.POINTER) | (1 << Fortran90Parser.ACCESSSPEC) | (1 << Fortran90Parser.IMPLICIT) | (1 << Fortran90Parser.CHARACTER) | (1 << Fortran90Parser.PARAMETER) | (1 << Fortran90Parser.EXTERNAL) | (1 << Fortran90Parser.INTRINSIC) | (1 << Fortran90Parser.SAVE) | (1 << Fortran90Parser.DATA) | (1 << Fortran90Parser.GO) | (1 << Fortran90Parser.GOTO) | (1 << Fortran90Parser.IF) | (1 << Fortran90Parser.DO) | (1 << Fortran90Parser.INCLUDE) | (1 << Fortran90Parser.CONTINUE) | (1 << Fortran90Parser.WHERE) | (1 << Fortran90Parser.SELECTCASE))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (Fortran90Parser.SELECT - 64)) | (1 << (Fortran90Parser.STOP - 64)) | (1 << (Fortran90Parser.PAUSE - 64)) | (1 << (Fortran90Parser.WRITE - 64)) | (1 << (Fortran90Parser.READ - 64)) | (1 << (Fortran90Parser.PRINT - 64)) | (1 << (Fortran90Parser.OPEN - 64)) | (1 << (Fortran90Parser.CALL - 64)) | (1 << (Fortran90Parser.RETURN - 64)) | (1 << (Fortran90Parser.CLOSE - 64)) | (1 << (Fortran90Parser.DOUBLE - 64)) | (1 << (Fortran90Parser.INQUIRE - 64)) | (1 << (Fortran90Parser.BACKSPACE - 64)) | (1 << (Fortran90Parser.ENDFILE - 64)) | (1 << (Fortran90Parser.REWIND - 64)) | (1 << (Fortran90Parser.ALLOCATE - 64)))) != 0) or ((((_la - 166)) & ~0x3f) == 0 and ((1 << (_la - 166)) & ((1 << (Fortran90Parser.COMPLEX - 166)) | (1 << (Fortran90Parser.INTEGER - 166)) | (1 << (Fortran90Parser.LOGICAL - 166)) | (1 << (Fortran90Parser.DEALLOCATE - 166)) | (1 << (Fortran90Parser.NULLIFY - 166)) | (1 << (Fortran90Parser.CYCLE - 166)) | (1 << (Fortran90Parser.INTERFACE - 166)) | (1 << (Fortran90Parser.ICON - 166)) | (1 << (Fortran90Parser.TYPE - 166)) | (1 << (Fortran90Parser.NAME - 166)) | (1 << (Fortran90Parser.EXIT - 166)))) != 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 ProgramUnitContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def mainProgram(self):
return self.getTypedRuleContext(Fortran90Parser.MainProgramContext,0)
[docs]
def functionSubprogram(self):
return self.getTypedRuleContext(Fortran90Parser.FunctionSubprogramContext,0)
[docs]
def subroutineSubprogram(self):
return self.getTypedRuleContext(Fortran90Parser.SubroutineSubprogramContext,0)
[docs]
def blockDataSubprogram(self):
return self.getTypedRuleContext(Fortran90Parser.BlockDataSubprogramContext,0)
[docs]
def module(self):
return self.getTypedRuleContext(Fortran90Parser.ModuleContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_programUnit
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterProgramUnit" ):
listener.enterProgramUnit(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitProgramUnit" ):
listener.exitProgramUnit(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitProgramUnit" ):
return visitor.visitProgramUnit(self)
else:
return visitor.visitChildren(self)
[docs]
def programUnit(self):
localctx = Fortran90Parser.ProgramUnitContext(self, self._ctx, self.state)
self.enterRule(localctx, 4, self.RULE_programUnit)
try:
self.state = 708
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,1,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 703
self.mainProgram()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 704
self.functionSubprogram()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 705
self.subroutineSubprogram()
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 706
self.blockDataSubprogram()
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 707
self.module()
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 mainRange(self):
return self.getTypedRuleContext(Fortran90Parser.MainRangeContext,0)
[docs]
def programStmt(self):
return self.getTypedRuleContext(Fortran90Parser.ProgramStmtContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.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 = Fortran90Parser.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 = 711
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.PROGRAM:
self.state = 710
self.programStmt()
self.state = 713
self.mainRange()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ProgramStmtContext(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(Fortran90Parser.PROGRAM, 0)
[docs]
def NAME(self):
return self.getToken(Fortran90Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_programStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterProgramStmt" ):
listener.enterProgramStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitProgramStmt" ):
listener.exitProgramStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitProgramStmt" ):
return visitor.visitProgramStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def programStmt(self):
localctx = Fortran90Parser.ProgramStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 8, self.RULE_programStmt)
try:
self.enterOuterAlt(localctx, 1)
self.state = 715
self.match(Fortran90Parser.PROGRAM)
self.state = 716
self.match(Fortran90Parser.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 MainRangeContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def endProgramStmt(self):
return self.getTypedRuleContext(Fortran90Parser.EndProgramStmtContext,0)
[docs]
def body(self):
return self.getTypedRuleContext(Fortran90Parser.BodyContext,0)
[docs]
def bodyPlusInternals(self):
return self.getTypedRuleContext(Fortran90Parser.BodyPlusInternalsContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_mainRange
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterMainRange" ):
listener.enterMainRange(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitMainRange" ):
listener.exitMainRange(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitMainRange" ):
return visitor.visitMainRange(self)
else:
return visitor.visitChildren(self)
[docs]
def mainRange(self):
localctx = Fortran90Parser.MainRangeContext(self, self._ctx, self.state)
self.enterRule(localctx, 10, self.RULE_mainRange)
try:
self.state = 725
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,4,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 719
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,3,self._ctx)
if la_ == 1:
self.state = 718
self.body()
self.state = 721
self.endProgramStmt()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 722
self.bodyPlusInternals(0)
self.state = 723
self.endProgramStmt()
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 BodyPlusInternalsContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def body(self):
return self.getTypedRuleContext(Fortran90Parser.BodyContext,0)
[docs]
def containsStmt(self):
return self.getTypedRuleContext(Fortran90Parser.ContainsStmtContext,0)
[docs]
def internalSubprogram(self):
return self.getTypedRuleContext(Fortran90Parser.InternalSubprogramContext,0)
[docs]
def bodyPlusInternals(self):
return self.getTypedRuleContext(Fortran90Parser.BodyPlusInternalsContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_bodyPlusInternals
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterBodyPlusInternals" ):
listener.enterBodyPlusInternals(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitBodyPlusInternals" ):
listener.exitBodyPlusInternals(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitBodyPlusInternals" ):
return visitor.visitBodyPlusInternals(self)
else:
return visitor.visitChildren(self)
[docs]
def bodyPlusInternals(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = Fortran90Parser.BodyPlusInternalsContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 12
self.enterRecursionRule(localctx, 12, self.RULE_bodyPlusInternals, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 735
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.ENTRY, Fortran90Parser.END, Fortran90Parser.DIMENSION, Fortran90Parser.TARGET, Fortran90Parser.ALLOCATABLE, Fortran90Parser.OPTIONAL, Fortran90Parser.NAMELIST, Fortran90Parser.INTENT, Fortran90Parser.USE, Fortran90Parser.DOUBLEPRECISION, Fortran90Parser.ASSIGNSTMT, Fortran90Parser.COMMON, Fortran90Parser.REAL, Fortran90Parser.EQUIVALENCE, Fortran90Parser.POINTER, Fortran90Parser.ACCESSSPEC, Fortran90Parser.IMPLICIT, Fortran90Parser.CHARACTER, Fortran90Parser.PARAMETER, Fortran90Parser.EXTERNAL, Fortran90Parser.INTRINSIC, Fortran90Parser.SAVE, Fortran90Parser.DATA, Fortran90Parser.GO, Fortran90Parser.GOTO, Fortran90Parser.IF, Fortran90Parser.DO, Fortran90Parser.INCLUDE, Fortran90Parser.CONTINUE, Fortran90Parser.WHERE, Fortran90Parser.SELECTCASE, Fortran90Parser.SELECT, Fortran90Parser.STOP, Fortran90Parser.PAUSE, Fortran90Parser.WRITE, Fortran90Parser.READ, Fortran90Parser.PRINT, Fortran90Parser.OPEN, Fortran90Parser.CALL, Fortran90Parser.RETURN, Fortran90Parser.CLOSE, Fortran90Parser.DOUBLE, Fortran90Parser.INQUIRE, Fortran90Parser.BACKSPACE, Fortran90Parser.ENDFILE, Fortran90Parser.REWIND, Fortran90Parser.ALLOCATE, Fortran90Parser.COMPLEX, Fortran90Parser.INTEGER, Fortran90Parser.LOGICAL, Fortran90Parser.DEALLOCATE, Fortran90Parser.NULLIFY, Fortran90Parser.CYCLE, Fortran90Parser.INTERFACE, Fortran90Parser.ICON, Fortran90Parser.TYPE, Fortran90Parser.NAME, Fortran90Parser.EXIT]:
self.state = 728
self.body()
self.state = 729
self.containsStmt()
self.state = 730
self.internalSubprogram()
pass
elif token in [Fortran90Parser.CONTAINS]:
self.state = 732
self.containsStmt()
self.state = 733
self.internalSubprogram()
pass
else:
raise NoViableAltException(self)
self._ctx.stop = self._input.LT(-1)
self.state = 741
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,6,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = Fortran90Parser.BodyPlusInternalsContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_bodyPlusInternals)
self.state = 737
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 738
self.internalSubprogram()
self.state = 743
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,6,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class InternalSubprogramContext(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(Fortran90Parser.FunctionSubprogramContext,0)
[docs]
def subroutineSubprogram(self):
return self.getTypedRuleContext(Fortran90Parser.SubroutineSubprogramContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_internalSubprogram
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterInternalSubprogram" ):
listener.enterInternalSubprogram(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitInternalSubprogram" ):
listener.exitInternalSubprogram(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitInternalSubprogram" ):
return visitor.visitInternalSubprogram(self)
else:
return visitor.visitChildren(self)
[docs]
def internalSubprogram(self):
localctx = Fortran90Parser.InternalSubprogramContext(self, self._ctx, self.state)
self.enterRule(localctx, 14, self.RULE_internalSubprogram)
try:
self.state = 746
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,7,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 744
self.functionSubprogram()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 745
self.subroutineSubprogram()
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 SpecificationPartConstructContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def implicitStmt(self):
return self.getTypedRuleContext(Fortran90Parser.ImplicitStmtContext,0)
[docs]
def parameterStmt(self):
return self.getTypedRuleContext(Fortran90Parser.ParameterStmtContext,0)
[docs]
def formatStmt(self):
return self.getTypedRuleContext(Fortran90Parser.FormatStmtContext,0)
[docs]
def entryStmt(self):
return self.getTypedRuleContext(Fortran90Parser.EntryStmtContext,0)
[docs]
def declarationConstruct(self):
return self.getTypedRuleContext(Fortran90Parser.DeclarationConstructContext,0)
[docs]
def includeStmt(self):
return self.getTypedRuleContext(Fortran90Parser.IncludeStmtContext,0)
[docs]
def useStmt(self):
return self.getTypedRuleContext(Fortran90Parser.UseStmtContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_specificationPartConstruct
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSpecificationPartConstruct" ):
listener.enterSpecificationPartConstruct(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSpecificationPartConstruct" ):
listener.exitSpecificationPartConstruct(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSpecificationPartConstruct" ):
return visitor.visitSpecificationPartConstruct(self)
else:
return visitor.visitChildren(self)
[docs]
def specificationPartConstruct(self):
localctx = Fortran90Parser.SpecificationPartConstructContext(self, self._ctx, self.state)
self.enterRule(localctx, 16, self.RULE_specificationPartConstruct)
try:
self.state = 755
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.IMPLICIT]:
self.enterOuterAlt(localctx, 1)
self.state = 748
self.implicitStmt()
pass
elif token in [Fortran90Parser.PARAMETER]:
self.enterOuterAlt(localctx, 2)
self.state = 749
self.parameterStmt()
pass
elif token in [Fortran90Parser.ICON]:
self.enterOuterAlt(localctx, 3)
self.state = 750
self.formatStmt()
pass
elif token in [Fortran90Parser.ENTRY]:
self.enterOuterAlt(localctx, 4)
self.state = 751
self.entryStmt()
pass
elif token in [Fortran90Parser.DIMENSION, Fortran90Parser.TARGET, Fortran90Parser.ALLOCATABLE, Fortran90Parser.OPTIONAL, Fortran90Parser.NAMELIST, Fortran90Parser.INTENT, Fortran90Parser.DOUBLEPRECISION, Fortran90Parser.COMMON, Fortran90Parser.REAL, Fortran90Parser.EQUIVALENCE, Fortran90Parser.POINTER, Fortran90Parser.ACCESSSPEC, Fortran90Parser.CHARACTER, Fortran90Parser.EXTERNAL, Fortran90Parser.INTRINSIC, Fortran90Parser.SAVE, Fortran90Parser.DATA, Fortran90Parser.DOUBLE, Fortran90Parser.COMPLEX, Fortran90Parser.INTEGER, Fortran90Parser.LOGICAL, Fortran90Parser.INTERFACE, Fortran90Parser.TYPE]:
self.enterOuterAlt(localctx, 5)
self.state = 752
self.declarationConstruct()
pass
elif token in [Fortran90Parser.INCLUDE]:
self.enterOuterAlt(localctx, 6)
self.state = 753
self.includeStmt()
pass
elif token in [Fortran90Parser.USE]:
self.enterOuterAlt(localctx, 7)
self.state = 754
self.useStmt()
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 UseStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def USE(self):
return self.getToken(Fortran90Parser.USE, 0)
[docs]
def NAME(self):
return self.getToken(Fortran90Parser.NAME, 0)
[docs]
def COMMA(self):
return self.getToken(Fortran90Parser.COMMA, 0)
[docs]
def ONLY(self):
return self.getToken(Fortran90Parser.ONLY, 0)
[docs]
def COLON(self):
return self.getToken(Fortran90Parser.COLON, 0)
[docs]
def renameList(self):
return self.getTypedRuleContext(Fortran90Parser.RenameListContext,0)
[docs]
def onlyList(self):
return self.getTypedRuleContext(Fortran90Parser.OnlyListContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_useStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterUseStmt" ):
listener.enterUseStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitUseStmt" ):
listener.exitUseStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitUseStmt" ):
return visitor.visitUseStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def useStmt(self):
localctx = Fortran90Parser.UseStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 18, self.RULE_useStmt)
try:
self.state = 774
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,9,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 757
self.match(Fortran90Parser.USE)
self.state = 758
self.match(Fortran90Parser.NAME)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 759
self.match(Fortran90Parser.USE)
self.state = 760
self.match(Fortran90Parser.NAME)
self.state = 761
self.match(Fortran90Parser.COMMA)
self.state = 762
self.match(Fortran90Parser.ONLY)
self.state = 763
self.match(Fortran90Parser.COLON)
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 764
self.match(Fortran90Parser.USE)
self.state = 765
self.match(Fortran90Parser.NAME)
self.state = 766
self.match(Fortran90Parser.COMMA)
self.state = 767
self.renameList()
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 768
self.match(Fortran90Parser.USE)
self.state = 769
self.match(Fortran90Parser.NAME)
self.state = 770
self.match(Fortran90Parser.COMMA)
self.state = 771
self.match(Fortran90Parser.ONLY)
self.state = 772
self.match(Fortran90Parser.COLON)
self.state = 773
self.onlyList()
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 OnlyListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def onlyStmt(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.OnlyStmtContext)
else:
return self.getTypedRuleContext(Fortran90Parser.OnlyStmtContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_onlyList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterOnlyList" ):
listener.enterOnlyList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitOnlyList" ):
listener.exitOnlyList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitOnlyList" ):
return visitor.visitOnlyList(self)
else:
return visitor.visitChildren(self)
[docs]
def onlyList(self):
localctx = Fortran90Parser.OnlyListContext(self, self._ctx, self.state)
self.enterRule(localctx, 20, self.RULE_onlyList)
try:
self.enterOuterAlt(localctx, 1)
self.state = 776
self.onlyStmt()
self.state = 781
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,10,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 777
self.match(Fortran90Parser.COMMA)
self.state = 778
self.onlyStmt()
self.state = 783
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,10,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 OnlyStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def genericSpec(self):
return self.getTypedRuleContext(Fortran90Parser.GenericSpecContext,0)
[docs]
def ident(self):
return self.getTypedRuleContext(Fortran90Parser.IdentContext,0)
[docs]
def IMPLIEDT(self):
return self.getToken(Fortran90Parser.IMPLIEDT, 0)
[docs]
def useName(self):
return self.getTypedRuleContext(Fortran90Parser.UseNameContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_onlyStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterOnlyStmt" ):
listener.enterOnlyStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitOnlyStmt" ):
listener.exitOnlyStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitOnlyStmt" ):
return visitor.visitOnlyStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def onlyStmt(self):
localctx = Fortran90Parser.OnlyStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 22, self.RULE_onlyStmt)
try:
self.state = 790
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,11,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 784
self.genericSpec()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 785
self.ident()
self.state = 786
self.match(Fortran90Parser.IMPLIEDT)
self.state = 787
self.useName()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 789
self.useName()
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 RenameListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def rename(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.RenameContext)
else:
return self.getTypedRuleContext(Fortran90Parser.RenameContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_renameList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterRenameList" ):
listener.enterRenameList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitRenameList" ):
listener.exitRenameList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitRenameList" ):
return visitor.visitRenameList(self)
else:
return visitor.visitChildren(self)
[docs]
def renameList(self):
localctx = Fortran90Parser.RenameListContext(self, self._ctx, self.state)
self.enterRule(localctx, 24, self.RULE_renameList)
try:
self.enterOuterAlt(localctx, 1)
self.state = 792
self.rename()
self.state = 797
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,12,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 793
self.match(Fortran90Parser.COMMA)
self.state = 794
self.rename()
self.state = 799
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,12,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 RenameContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ident(self):
return self.getTypedRuleContext(Fortran90Parser.IdentContext,0)
[docs]
def IMPLIEDT(self):
return self.getToken(Fortran90Parser.IMPLIEDT, 0)
[docs]
def useName(self):
return self.getTypedRuleContext(Fortran90Parser.UseNameContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_rename
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterRename" ):
listener.enterRename(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitRename" ):
listener.exitRename(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitRename" ):
return visitor.visitRename(self)
else:
return visitor.visitChildren(self)
[docs]
def rename(self):
localctx = Fortran90Parser.RenameContext(self, self._ctx, self.state)
self.enterRule(localctx, 26, self.RULE_rename)
try:
self.enterOuterAlt(localctx, 1)
self.state = 800
self.ident()
self.state = 801
self.match(Fortran90Parser.IMPLIEDT)
self.state = 802
self.useName()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class UseNameContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ident(self):
return self.getTypedRuleContext(Fortran90Parser.IdentContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_useName
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterUseName" ):
listener.enterUseName(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitUseName" ):
listener.exitUseName(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitUseName" ):
return visitor.visitUseName(self)
else:
return visitor.visitChildren(self)
[docs]
def useName(self):
localctx = Fortran90Parser.UseNameContext(self, self._ctx, self.state)
self.enterRule(localctx, 28, self.RULE_useName)
try:
self.enterOuterAlt(localctx, 1)
self.state = 804
self.ident()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ParameterStmtContext(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(Fortran90Parser.PARAMETER, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def namedConstantDefList(self):
return self.getTypedRuleContext(Fortran90Parser.NamedConstantDefListContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_parameterStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterParameterStmt" ):
listener.enterParameterStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitParameterStmt" ):
listener.exitParameterStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitParameterStmt" ):
return visitor.visitParameterStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def parameterStmt(self):
localctx = Fortran90Parser.ParameterStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 30, self.RULE_parameterStmt)
try:
self.enterOuterAlt(localctx, 1)
self.state = 806
self.match(Fortran90Parser.PARAMETER)
self.state = 807
self.match(Fortran90Parser.LPAREN)
self.state = 808
self.namedConstantDefList()
self.state = 809
self.match(Fortran90Parser.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 NamedConstantDefListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def namedConstantDef(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.NamedConstantDefContext)
else:
return self.getTypedRuleContext(Fortran90Parser.NamedConstantDefContext,i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_namedConstantDefList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterNamedConstantDefList" ):
listener.enterNamedConstantDefList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitNamedConstantDefList" ):
listener.exitNamedConstantDefList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNamedConstantDefList" ):
return visitor.visitNamedConstantDefList(self)
else:
return visitor.visitChildren(self)
[docs]
def namedConstantDefList(self):
localctx = Fortran90Parser.NamedConstantDefListContext(self, self._ctx, self.state)
self.enterRule(localctx, 32, self.RULE_namedConstantDefList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 812
self._errHandler.sync(self)
_la = self._input.LA(1)
while True:
self.state = 811
self.namedConstantDef()
self.state = 814
self._errHandler.sync(self)
_la = self._input.LA(1)
if not (_la==Fortran90Parser.NAME):
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 NamedConstantDefContext(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(Fortran90Parser.NAME, 0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran90Parser.ASSIGN, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_namedConstantDef
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterNamedConstantDef" ):
listener.enterNamedConstantDef(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitNamedConstantDef" ):
listener.exitNamedConstantDef(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNamedConstantDef" ):
return visitor.visitNamedConstantDef(self)
else:
return visitor.visitChildren(self)
[docs]
def namedConstantDef(self):
localctx = Fortran90Parser.NamedConstantDefContext(self, self._ctx, self.state)
self.enterRule(localctx, 34, self.RULE_namedConstantDef)
try:
self.enterOuterAlt(localctx, 1)
self.state = 816
self.match(Fortran90Parser.NAME)
self.state = 817
self.match(Fortran90Parser.ASSIGN)
self.state = 818
self.expression(0)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class EndProgramStmtContext(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(Fortran90Parser.END, 0)
[docs]
def PROGRAM(self):
return self.getToken(Fortran90Parser.PROGRAM, 0)
[docs]
def NAME(self):
return self.getToken(Fortran90Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_endProgramStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEndProgramStmt" ):
listener.enterEndProgramStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEndProgramStmt" ):
listener.exitEndProgramStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEndProgramStmt" ):
return visitor.visitEndProgramStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def endProgramStmt(self):
localctx = Fortran90Parser.EndProgramStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 36, self.RULE_endProgramStmt)
try:
self.state = 826
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,15,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 820
self.match(Fortran90Parser.END)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 821
self.match(Fortran90Parser.END)
self.state = 822
self.match(Fortran90Parser.PROGRAM)
self.state = 824
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,14,self._ctx)
if la_ == 1:
self.state = 823
self.match(Fortran90Parser.NAME)
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 BlockDataSubprogramContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def blockDataStmt(self):
return self.getTypedRuleContext(Fortran90Parser.BlockDataStmtContext,0)
[docs]
def blockDataBody(self):
return self.getTypedRuleContext(Fortran90Parser.BlockDataBodyContext,0)
[docs]
def endBlockDataStmt(self):
return self.getTypedRuleContext(Fortran90Parser.EndBlockDataStmtContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.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 = Fortran90Parser.BlockDataSubprogramContext(self, self._ctx, self.state)
self.enterRule(localctx, 38, self.RULE_blockDataSubprogram)
try:
self.state = 835
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,16,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 828
self.blockDataStmt()
self.state = 829
self.blockDataBody(0)
self.state = 830
self.endBlockDataStmt()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 832
self.blockDataStmt()
self.state = 833
self.endBlockDataStmt()
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 BlockDataStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def BLOCKDATA(self):
return self.getToken(Fortran90Parser.BLOCKDATA, 0)
[docs]
def NAME(self):
return self.getToken(Fortran90Parser.NAME, 0)
[docs]
def BLOCK(self):
return self.getToken(Fortran90Parser.BLOCK, 0)
[docs]
def DATA(self):
return self.getToken(Fortran90Parser.DATA, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_blockDataStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterBlockDataStmt" ):
listener.enterBlockDataStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitBlockDataStmt" ):
listener.exitBlockDataStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitBlockDataStmt" ):
return visitor.visitBlockDataStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def blockDataStmt(self):
localctx = Fortran90Parser.BlockDataStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 40, self.RULE_blockDataStmt)
self._la = 0 # Token type
try:
self.state = 846
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.BLOCKDATA]:
self.enterOuterAlt(localctx, 1)
self.state = 837
self.match(Fortran90Parser.BLOCKDATA)
self.state = 839
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.NAME:
self.state = 838
self.match(Fortran90Parser.NAME)
pass
elif token in [Fortran90Parser.BLOCK]:
self.enterOuterAlt(localctx, 2)
self.state = 841
self.match(Fortran90Parser.BLOCK)
self.state = 842
self.match(Fortran90Parser.DATA)
self.state = 844
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.NAME:
self.state = 843
self.match(Fortran90Parser.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 BlockDataBodyContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def blockDataBodyConstruct(self):
return self.getTypedRuleContext(Fortran90Parser.BlockDataBodyConstructContext,0)
[docs]
def blockDataBody(self):
return self.getTypedRuleContext(Fortran90Parser.BlockDataBodyContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_blockDataBody
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterBlockDataBody" ):
listener.enterBlockDataBody(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitBlockDataBody" ):
listener.exitBlockDataBody(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitBlockDataBody" ):
return visitor.visitBlockDataBody(self)
else:
return visitor.visitChildren(self)
[docs]
def blockDataBody(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = Fortran90Parser.BlockDataBodyContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 42
self.enterRecursionRule(localctx, 42, self.RULE_blockDataBody, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 849
self.blockDataBodyConstruct()
self._ctx.stop = self._input.LT(-1)
self.state = 855
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,20,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = Fortran90Parser.BlockDataBodyContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_blockDataBody)
self.state = 851
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 852
self.blockDataBodyConstruct()
self.state = 857
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,20,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class BlockDataBodyConstructContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def specificationPartConstruct(self):
return self.getTypedRuleContext(Fortran90Parser.SpecificationPartConstructContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_blockDataBodyConstruct
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterBlockDataBodyConstruct" ):
listener.enterBlockDataBodyConstruct(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitBlockDataBodyConstruct" ):
listener.exitBlockDataBodyConstruct(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitBlockDataBodyConstruct" ):
return visitor.visitBlockDataBodyConstruct(self)
else:
return visitor.visitChildren(self)
[docs]
def blockDataBodyConstruct(self):
localctx = Fortran90Parser.BlockDataBodyConstructContext(self, self._ctx, self.state)
self.enterRule(localctx, 44, self.RULE_blockDataBodyConstruct)
try:
self.enterOuterAlt(localctx, 1)
self.state = 858
self.specificationPartConstruct()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class EndBlockDataStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ENDBLOCKDATA(self):
return self.getToken(Fortran90Parser.ENDBLOCKDATA, 0)
[docs]
def NAME(self):
return self.getToken(Fortran90Parser.NAME, 0)
[docs]
def END(self):
return self.getToken(Fortran90Parser.END, 0)
[docs]
def BLOCKDATA(self):
return self.getToken(Fortran90Parser.BLOCKDATA, 0)
[docs]
def ENDBLOCK(self):
return self.getToken(Fortran90Parser.ENDBLOCK, 0)
[docs]
def DATA(self):
return self.getToken(Fortran90Parser.DATA, 0)
[docs]
def BLOCK(self):
return self.getToken(Fortran90Parser.BLOCK, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_endBlockDataStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEndBlockDataStmt" ):
listener.enterEndBlockDataStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEndBlockDataStmt" ):
listener.exitEndBlockDataStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEndBlockDataStmt" ):
return visitor.visitEndBlockDataStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def endBlockDataStmt(self):
localctx = Fortran90Parser.EndBlockDataStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 46, self.RULE_endBlockDataStmt)
try:
self.state = 881
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,25,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 860
self.match(Fortran90Parser.ENDBLOCKDATA)
self.state = 862
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,21,self._ctx)
if la_ == 1:
self.state = 861
self.match(Fortran90Parser.NAME)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 864
self.match(Fortran90Parser.END)
self.state = 865
self.match(Fortran90Parser.BLOCKDATA)
self.state = 867
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,22,self._ctx)
if la_ == 1:
self.state = 866
self.match(Fortran90Parser.NAME)
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 869
self.match(Fortran90Parser.ENDBLOCK)
self.state = 870
self.match(Fortran90Parser.DATA)
self.state = 872
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,23,self._ctx)
if la_ == 1:
self.state = 871
self.match(Fortran90Parser.NAME)
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 874
self.match(Fortran90Parser.END)
self.state = 875
self.match(Fortran90Parser.BLOCK)
self.state = 876
self.match(Fortran90Parser.DATA)
self.state = 878
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,24,self._ctx)
if la_ == 1:
self.state = 877
self.match(Fortran90Parser.NAME)
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 880
self.match(Fortran90Parser.END)
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 FormatStmtContext(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(Fortran90Parser.ICON, 0)
[docs]
def FORMAT(self):
return self.getToken(Fortran90Parser.FORMAT, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def fmtSpec(self):
return self.getTypedRuleContext(Fortran90Parser.FmtSpecContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_formatStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterFormatStmt" ):
listener.enterFormatStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitFormatStmt" ):
listener.exitFormatStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFormatStmt" ):
return visitor.visitFormatStmt(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):
return self.getTypedRuleContext(Fortran90Parser.FormateditContext,0)
[docs]
def FORMATSEP(self):
return self.getToken(Fortran90Parser.FORMATSEP, 0)
[docs]
def fmtSpec(self):
return self.getTypedRuleContext(Fortran90Parser.FmtSpecContext,0)
[docs]
def COMMA(self):
return self.getToken(Fortran90Parser.COMMA, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.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, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = Fortran90Parser.FmtSpecContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 50
self.enterRecursionRule(localctx, 50, self.RULE_fmtSpec, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 896
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,27,self._ctx)
if la_ == 1:
self.state = 892
self.formatedit()
pass
elif la_ == 2:
self.state = 893
self.match(Fortran90Parser.FORMATSEP)
pass
elif la_ == 3:
self.state = 894
self.match(Fortran90Parser.FORMATSEP)
self.state = 895
self.formatedit()
pass
self._ctx.stop = self._input.LT(-1)
self.state = 915
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,29,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
self.state = 913
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,28,self._ctx)
if la_ == 1:
localctx = Fortran90Parser.FmtSpecContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_fmtSpec)
self.state = 898
if not self.precpred(self._ctx, 5):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
self.state = 899
self.match(Fortran90Parser.FORMATSEP)
pass
elif la_ == 2:
localctx = Fortran90Parser.FmtSpecContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_fmtSpec)
self.state = 900
if not self.precpred(self._ctx, 4):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
self.state = 901
self.match(Fortran90Parser.FORMATSEP)
self.state = 902
self.formatedit()
pass
elif la_ == 3:
localctx = Fortran90Parser.FmtSpecContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_fmtSpec)
self.state = 903
if not self.precpred(self._ctx, 3):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
self.state = 904
self.match(Fortran90Parser.COMMA)
self.state = 905
self.formatedit()
pass
elif la_ == 4:
localctx = Fortran90Parser.FmtSpecContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_fmtSpec)
self.state = 906
if not self.precpred(self._ctx, 2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
self.state = 907
self.match(Fortran90Parser.COMMA)
self.state = 908
self.match(Fortran90Parser.FORMATSEP)
pass
elif la_ == 5:
localctx = Fortran90Parser.FmtSpecContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_fmtSpec)
self.state = 909
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 910
self.match(Fortran90Parser.COMMA)
self.state = 911
self.match(Fortran90Parser.FORMATSEP)
self.state = 912
self.formatedit()
pass
self.state = 917
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,29,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class FormateditContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def editElement(self):
return self.getTypedRuleContext(Fortran90Parser.EditElementContext,0)
[docs]
def ICON(self):
return self.getToken(Fortran90Parser.ICON, 0)
[docs]
def XCON(self):
return self.getToken(Fortran90Parser.XCON, 0)
[docs]
def PCON(self):
return self.getToken(Fortran90Parser.PCON, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.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(Fortran90Parser.FCON, 0)
[docs]
def mislexedFcon(self):
return self.getTypedRuleContext(Fortran90Parser.MislexedFconContext,0)
[docs]
def SCON(self):
return self.getToken(Fortran90Parser.SCON, 0)
[docs]
def HOLLERITH(self):
return self.getToken(Fortran90Parser.HOLLERITH, 0)
[docs]
def NAME(self):
return self.getToken(Fortran90Parser.NAME, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def fmtSpec(self):
return self.getTypedRuleContext(Fortran90Parser.FmtSpecContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.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 = Fortran90Parser.EditElementContext(self, self._ctx, self.state)
self.enterRule(localctx, 54, self.RULE_editElement)
try:
self.state = 939
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,31,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 930
self.match(Fortran90Parser.FCON)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 931
self.mislexedFcon()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 932
self.match(Fortran90Parser.SCON)
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 933
self.match(Fortran90Parser.HOLLERITH)
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 934
self.match(Fortran90Parser.NAME)
pass
elif la_ == 6:
self.enterOuterAlt(localctx, 6)
self.state = 935
self.match(Fortran90Parser.LPAREN)
self.state = 936
self.fmtSpec(0)
self.state = 937
self.match(Fortran90Parser.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 MislexedFconContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def RDCON(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.RDCON)
else:
return self.getToken(Fortran90Parser.RDCON, i)
[docs]
def SPOFF(self):
return self.getToken(Fortran90Parser.SPOFF, 0)
[docs]
def SPON(self):
return self.getToken(Fortran90Parser.SPON, 0)
[docs]
def NAME(self):
return self.getToken(Fortran90Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_mislexedFcon
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterMislexedFcon" ):
listener.enterMislexedFcon(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitMislexedFcon" ):
listener.exitMislexedFcon(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitMislexedFcon" ):
return visitor.visitMislexedFcon(self)
else:
return visitor.visitChildren(self)
[docs]
def mislexedFcon(self):
localctx = Fortran90Parser.MislexedFconContext(self, self._ctx, self.state)
self.enterRule(localctx, 56, self.RULE_mislexedFcon)
try:
self.state = 949
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.RDCON]:
self.enterOuterAlt(localctx, 1)
self.state = 941
self.match(Fortran90Parser.RDCON)
self.state = 942
self.match(Fortran90Parser.SPOFF)
self.state = 943
self.match(Fortran90Parser.RDCON)
self.state = 944
self.match(Fortran90Parser.SPON)
pass
elif token in [Fortran90Parser.NAME]:
self.enterOuterAlt(localctx, 2)
self.state = 945
self.match(Fortran90Parser.NAME)
self.state = 946
self.match(Fortran90Parser.SPOFF)
self.state = 947
self.match(Fortran90Parser.RDCON)
self.state = 948
self.match(Fortran90Parser.SPON)
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 ModuleContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def moduleStmt(self):
return self.getTypedRuleContext(Fortran90Parser.ModuleStmtContext,0)
[docs]
def moduleBody(self):
return self.getTypedRuleContext(Fortran90Parser.ModuleBodyContext,0)
[docs]
def endModuleStmt(self):
return self.getTypedRuleContext(Fortran90Parser.EndModuleStmtContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_module
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterModule" ):
listener.enterModule(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitModule" ):
listener.exitModule(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitModule" ):
return visitor.visitModule(self)
else:
return visitor.visitChildren(self)
[docs]
def module(self):
localctx = Fortran90Parser.ModuleContext(self, self._ctx, self.state)
self.enterRule(localctx, 58, self.RULE_module)
try:
self.state = 958
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,33,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 951
self.moduleStmt()
self.state = 952
self.moduleBody(0)
self.state = 953
self.endModuleStmt()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 955
self.moduleStmt()
self.state = 956
self.endModuleStmt()
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 EndModuleStmtContext(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(Fortran90Parser.END, 0)
[docs]
def MODULE(self):
return self.getToken(Fortran90Parser.MODULE, 0)
[docs]
def NAME(self):
return self.getToken(Fortran90Parser.NAME, 0)
[docs]
def ENDMODULE(self):
return self.getToken(Fortran90Parser.ENDMODULE, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_endModuleStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEndModuleStmt" ):
listener.enterEndModuleStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEndModuleStmt" ):
listener.exitEndModuleStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEndModuleStmt" ):
return visitor.visitEndModuleStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def endModuleStmt(self):
localctx = Fortran90Parser.EndModuleStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 60, self.RULE_endModuleStmt)
try:
self.state = 970
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,36,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 960
self.match(Fortran90Parser.END)
self.state = 961
self.match(Fortran90Parser.MODULE)
self.state = 963
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,34,self._ctx)
if la_ == 1:
self.state = 962
self.match(Fortran90Parser.NAME)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 965
self.match(Fortran90Parser.ENDMODULE)
self.state = 967
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
if la_ == 1:
self.state = 966
self.match(Fortran90Parser.NAME)
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 969
self.match(Fortran90Parser.END)
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 EntryStmtContext(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(Fortran90Parser.ENTRY, 0)
[docs]
def NAME(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.NAME)
else:
return self.getToken(Fortran90Parser.NAME, i)
[docs]
def subroutineParList(self):
return self.getTypedRuleContext(Fortran90Parser.SubroutineParListContext,0)
[docs]
def RESULT(self):
return self.getToken(Fortran90Parser.RESULT, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_entryStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEntryStmt" ):
listener.enterEntryStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEntryStmt" ):
listener.exitEntryStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEntryStmt" ):
return visitor.visitEntryStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def entryStmt(self):
localctx = Fortran90Parser.EntryStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 62, self.RULE_entryStmt)
try:
self.enterOuterAlt(localctx, 1)
self.state = 972
self.match(Fortran90Parser.ENTRY)
self.state = 973
self.match(Fortran90Parser.NAME)
self.state = 974
self.subroutineParList()
self.state = 975
self.match(Fortran90Parser.RESULT)
self.state = 976
self.match(Fortran90Parser.LPAREN)
self.state = 977
self.match(Fortran90Parser.NAME)
self.state = 978
self.match(Fortran90Parser.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 SubroutineParListContext(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(Fortran90Parser.LPAREN, 0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def subroutinePars(self):
return self.getTypedRuleContext(Fortran90Parser.SubroutineParsContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_subroutineParList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSubroutineParList" ):
listener.enterSubroutineParList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSubroutineParList" ):
listener.exitSubroutineParList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSubroutineParList" ):
return visitor.visitSubroutineParList(self)
else:
return visitor.visitChildren(self)
[docs]
def subroutineParList(self):
localctx = Fortran90Parser.SubroutineParListContext(self, self._ctx, self.state)
self.enterRule(localctx, 64, self.RULE_subroutineParList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 985
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.LPAREN:
self.state = 980
self.match(Fortran90Parser.LPAREN)
self.state = 982
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.NAME or _la==Fortran90Parser.STAR:
self.state = 981
self.subroutinePars()
self.state = 984
self.match(Fortran90Parser.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 SubroutineParsContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def subroutinePar(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.SubroutineParContext)
else:
return self.getTypedRuleContext(Fortran90Parser.SubroutineParContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_subroutinePars
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSubroutinePars" ):
listener.enterSubroutinePars(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSubroutinePars" ):
listener.exitSubroutinePars(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSubroutinePars" ):
return visitor.visitSubroutinePars(self)
else:
return visitor.visitChildren(self)
[docs]
def subroutinePars(self):
localctx = Fortran90Parser.SubroutineParsContext(self, self._ctx, self.state)
self.enterRule(localctx, 66, self.RULE_subroutinePars)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 987
self.subroutinePar()
self.state = 992
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran90Parser.COMMA:
self.state = 988
self.match(Fortran90Parser.COMMA)
self.state = 989
self.subroutinePar()
self.state = 994
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 SubroutineParContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def dummyArgName(self):
return self.getTypedRuleContext(Fortran90Parser.DummyArgNameContext,0)
[docs]
def STAR(self):
return self.getToken(Fortran90Parser.STAR, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_subroutinePar
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSubroutinePar" ):
listener.enterSubroutinePar(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSubroutinePar" ):
listener.exitSubroutinePar(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSubroutinePar" ):
return visitor.visitSubroutinePar(self)
else:
return visitor.visitChildren(self)
[docs]
def subroutinePar(self):
localctx = Fortran90Parser.SubroutineParContext(self, self._ctx, self.state)
self.enterRule(localctx, 68, self.RULE_subroutinePar)
try:
self.state = 997
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.NAME]:
self.enterOuterAlt(localctx, 1)
self.state = 995
self.dummyArgName()
pass
elif token in [Fortran90Parser.STAR]:
self.enterOuterAlt(localctx, 2)
self.state = 996
self.match(Fortran90Parser.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 DeclarationConstructContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def derivedTypeDef(self):
return self.getTypedRuleContext(Fortran90Parser.DerivedTypeDefContext,0)
[docs]
def interfaceBlock(self):
return self.getTypedRuleContext(Fortran90Parser.InterfaceBlockContext,0)
[docs]
def typeDeclarationStmt(self):
return self.getTypedRuleContext(Fortran90Parser.TypeDeclarationStmtContext,0)
[docs]
def specificationStmt(self):
return self.getTypedRuleContext(Fortran90Parser.SpecificationStmtContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_declarationConstruct
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDeclarationConstruct" ):
listener.enterDeclarationConstruct(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDeclarationConstruct" ):
listener.exitDeclarationConstruct(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDeclarationConstruct" ):
return visitor.visitDeclarationConstruct(self)
else:
return visitor.visitChildren(self)
[docs]
def declarationConstruct(self):
localctx = Fortran90Parser.DeclarationConstructContext(self, self._ctx, self.state)
self.enterRule(localctx, 70, self.RULE_declarationConstruct)
try:
self.state = 1003
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,41,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 999
self.derivedTypeDef()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1000
self.interfaceBlock()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 1001
self.typeDeclarationStmt()
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 1002
self.specificationStmt()
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 SpecificationStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def commonStmt(self):
return self.getTypedRuleContext(Fortran90Parser.CommonStmtContext,0)
[docs]
def dataStmt(self):
return self.getTypedRuleContext(Fortran90Parser.DataStmtContext,0)
[docs]
def dimensionStmt(self):
return self.getTypedRuleContext(Fortran90Parser.DimensionStmtContext,0)
[docs]
def equivalenceStmt(self):
return self.getTypedRuleContext(Fortran90Parser.EquivalenceStmtContext,0)
[docs]
def externalStmt(self):
return self.getTypedRuleContext(Fortran90Parser.ExternalStmtContext,0)
[docs]
def intrinsicStmt(self):
return self.getTypedRuleContext(Fortran90Parser.IntrinsicStmtContext,0)
[docs]
def saveStmt(self):
return self.getTypedRuleContext(Fortran90Parser.SaveStmtContext,0)
[docs]
def accessStmt(self):
return self.getTypedRuleContext(Fortran90Parser.AccessStmtContext,0)
[docs]
def allocatableStmt(self):
return self.getTypedRuleContext(Fortran90Parser.AllocatableStmtContext,0)
[docs]
def intentStmt(self):
return self.getTypedRuleContext(Fortran90Parser.IntentStmtContext,0)
[docs]
def namelistStmt(self):
return self.getTypedRuleContext(Fortran90Parser.NamelistStmtContext,0)
[docs]
def optionalStmt(self):
return self.getTypedRuleContext(Fortran90Parser.OptionalStmtContext,0)
[docs]
def pointerStmt(self):
return self.getTypedRuleContext(Fortran90Parser.PointerStmtContext,0)
[docs]
def targetStmt(self):
return self.getTypedRuleContext(Fortran90Parser.TargetStmtContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_specificationStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSpecificationStmt" ):
listener.enterSpecificationStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSpecificationStmt" ):
listener.exitSpecificationStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSpecificationStmt" ):
return visitor.visitSpecificationStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def specificationStmt(self):
localctx = Fortran90Parser.SpecificationStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 72, self.RULE_specificationStmt)
try:
self.state = 1019
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.COMMON]:
self.enterOuterAlt(localctx, 1)
self.state = 1005
self.commonStmt()
pass
elif token in [Fortran90Parser.DATA]:
self.enterOuterAlt(localctx, 2)
self.state = 1006
self.dataStmt()
pass
elif token in [Fortran90Parser.DIMENSION]:
self.enterOuterAlt(localctx, 3)
self.state = 1007
self.dimensionStmt()
pass
elif token in [Fortran90Parser.EQUIVALENCE]:
self.enterOuterAlt(localctx, 4)
self.state = 1008
self.equivalenceStmt()
pass
elif token in [Fortran90Parser.EXTERNAL]:
self.enterOuterAlt(localctx, 5)
self.state = 1009
self.externalStmt()
pass
elif token in [Fortran90Parser.INTRINSIC]:
self.enterOuterAlt(localctx, 6)
self.state = 1010
self.intrinsicStmt()
pass
elif token in [Fortran90Parser.SAVE]:
self.enterOuterAlt(localctx, 7)
self.state = 1011
self.saveStmt()
pass
elif token in [Fortran90Parser.ACCESSSPEC]:
self.enterOuterAlt(localctx, 8)
self.state = 1012
self.accessStmt()
pass
elif token in [Fortran90Parser.ALLOCATABLE]:
self.enterOuterAlt(localctx, 9)
self.state = 1013
self.allocatableStmt()
pass
elif token in [Fortran90Parser.INTENT]:
self.enterOuterAlt(localctx, 10)
self.state = 1014
self.intentStmt()
pass
elif token in [Fortran90Parser.NAMELIST]:
self.enterOuterAlt(localctx, 11)
self.state = 1015
self.namelistStmt()
pass
elif token in [Fortran90Parser.OPTIONAL]:
self.enterOuterAlt(localctx, 12)
self.state = 1016
self.optionalStmt()
pass
elif token in [Fortran90Parser.POINTER]:
self.enterOuterAlt(localctx, 13)
self.state = 1017
self.pointerStmt()
pass
elif token in [Fortran90Parser.TARGET]:
self.enterOuterAlt(localctx, 14)
self.state = 1018
self.targetStmt()
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 TargetStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def TARGET(self):
return self.getToken(Fortran90Parser.TARGET, 0)
[docs]
def targetObjectList(self):
return self.getTypedRuleContext(Fortran90Parser.TargetObjectListContext,0)
[docs]
def DOUBLECOLON(self):
return self.getToken(Fortran90Parser.DOUBLECOLON, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_targetStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTargetStmt" ):
listener.enterTargetStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTargetStmt" ):
listener.exitTargetStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTargetStmt" ):
return visitor.visitTargetStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def targetStmt(self):
localctx = Fortran90Parser.TargetStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 74, self.RULE_targetStmt)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1021
self.match(Fortran90Parser.TARGET)
self.state = 1023
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.DOUBLECOLON:
self.state = 1022
self.match(Fortran90Parser.DOUBLECOLON)
self.state = 1025
self.targetObjectList()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class TargetObjectListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def targetObject(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.TargetObjectContext)
else:
return self.getTypedRuleContext(Fortran90Parser.TargetObjectContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_targetObjectList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTargetObjectList" ):
listener.enterTargetObjectList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTargetObjectList" ):
listener.exitTargetObjectList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTargetObjectList" ):
return visitor.visitTargetObjectList(self)
else:
return visitor.visitChildren(self)
[docs]
def targetObjectList(self):
localctx = Fortran90Parser.TargetObjectListContext(self, self._ctx, self.state)
self.enterRule(localctx, 76, self.RULE_targetObjectList)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1027
self.targetObject()
self.state = 1032
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,44,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 1028
self.match(Fortran90Parser.COMMA)
self.state = 1029
self.targetObject()
self.state = 1034
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,44,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 TargetObjectContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def objectName(self):
return self.getTypedRuleContext(Fortran90Parser.ObjectNameContext,0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def arraySpec(self):
return self.getTypedRuleContext(Fortran90Parser.ArraySpecContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_targetObject
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTargetObject" ):
listener.enterTargetObject(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTargetObject" ):
listener.exitTargetObject(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTargetObject" ):
return visitor.visitTargetObject(self)
else:
return visitor.visitChildren(self)
[docs]
def targetObject(self):
localctx = Fortran90Parser.TargetObjectContext(self, self._ctx, self.state)
self.enterRule(localctx, 78, self.RULE_targetObject)
try:
self.state = 1041
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,45,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1035
self.objectName()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1036
self.objectName()
self.state = 1037
self.match(Fortran90Parser.LPAREN)
self.state = 1038
self.arraySpec()
self.state = 1039
self.match(Fortran90Parser.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 PointerStmtContext(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(Fortran90Parser.POINTER, 0)
[docs]
def pointerStmtObjectList(self):
return self.getTypedRuleContext(Fortran90Parser.PointerStmtObjectListContext,0)
[docs]
def DOUBLECOLON(self):
return self.getToken(Fortran90Parser.DOUBLECOLON, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_pointerStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPointerStmt" ):
listener.enterPointerStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPointerStmt" ):
listener.exitPointerStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPointerStmt" ):
return visitor.visitPointerStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def pointerStmt(self):
localctx = Fortran90Parser.PointerStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 80, self.RULE_pointerStmt)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1043
self.match(Fortran90Parser.POINTER)
self.state = 1045
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.DOUBLECOLON:
self.state = 1044
self.match(Fortran90Parser.DOUBLECOLON)
self.state = 1047
self.pointerStmtObjectList()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class PointerStmtObjectListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def pointerStmtObject(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.PointerStmtObjectContext)
else:
return self.getTypedRuleContext(Fortran90Parser.PointerStmtObjectContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_pointerStmtObjectList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPointerStmtObjectList" ):
listener.enterPointerStmtObjectList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPointerStmtObjectList" ):
listener.exitPointerStmtObjectList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPointerStmtObjectList" ):
return visitor.visitPointerStmtObjectList(self)
else:
return visitor.visitChildren(self)
[docs]
def pointerStmtObjectList(self):
localctx = Fortran90Parser.PointerStmtObjectListContext(self, self._ctx, self.state)
self.enterRule(localctx, 82, self.RULE_pointerStmtObjectList)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1049
self.pointerStmtObject()
self.state = 1054
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,47,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 1050
self.match(Fortran90Parser.COMMA)
self.state = 1051
self.pointerStmtObject()
self.state = 1056
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,47,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 PointerStmtObjectContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def objectName(self):
return self.getTypedRuleContext(Fortran90Parser.ObjectNameContext,0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def deferredShapeSpecList(self):
return self.getTypedRuleContext(Fortran90Parser.DeferredShapeSpecListContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_pointerStmtObject
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPointerStmtObject" ):
listener.enterPointerStmtObject(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPointerStmtObject" ):
listener.exitPointerStmtObject(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPointerStmtObject" ):
return visitor.visitPointerStmtObject(self)
else:
return visitor.visitChildren(self)
[docs]
def pointerStmtObject(self):
localctx = Fortran90Parser.PointerStmtObjectContext(self, self._ctx, self.state)
self.enterRule(localctx, 84, self.RULE_pointerStmtObject)
try:
self.state = 1063
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,48,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1057
self.objectName()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1058
self.objectName()
self.state = 1059
self.match(Fortran90Parser.LPAREN)
self.state = 1060
self.deferredShapeSpecList()
self.state = 1061
self.match(Fortran90Parser.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 OptionalStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def OPTIONAL(self):
return self.getToken(Fortran90Parser.OPTIONAL, 0)
[docs]
def optionalParList(self):
return self.getTypedRuleContext(Fortran90Parser.OptionalParListContext,0)
[docs]
def DOUBLECOLON(self):
return self.getToken(Fortran90Parser.DOUBLECOLON, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_optionalStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterOptionalStmt" ):
listener.enterOptionalStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitOptionalStmt" ):
listener.exitOptionalStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitOptionalStmt" ):
return visitor.visitOptionalStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def optionalStmt(self):
localctx = Fortran90Parser.OptionalStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 86, self.RULE_optionalStmt)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1065
self.match(Fortran90Parser.OPTIONAL)
self.state = 1067
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.DOUBLECOLON:
self.state = 1066
self.match(Fortran90Parser.DOUBLECOLON)
self.state = 1069
self.optionalParList()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class OptionalParListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def optionalPar(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.OptionalParContext)
else:
return self.getTypedRuleContext(Fortran90Parser.OptionalParContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_optionalParList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterOptionalParList" ):
listener.enterOptionalParList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitOptionalParList" ):
listener.exitOptionalParList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitOptionalParList" ):
return visitor.visitOptionalParList(self)
else:
return visitor.visitChildren(self)
[docs]
def optionalParList(self):
localctx = Fortran90Parser.OptionalParListContext(self, self._ctx, self.state)
self.enterRule(localctx, 88, self.RULE_optionalParList)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1071
self.optionalPar()
self.state = 1076
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,50,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 1072
self.match(Fortran90Parser.COMMA)
self.state = 1073
self.optionalPar()
self.state = 1078
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,50,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 OptionalParContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def dummyArgName(self):
return self.getTypedRuleContext(Fortran90Parser.DummyArgNameContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_optionalPar
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterOptionalPar" ):
listener.enterOptionalPar(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitOptionalPar" ):
listener.exitOptionalPar(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitOptionalPar" ):
return visitor.visitOptionalPar(self)
else:
return visitor.visitChildren(self)
[docs]
def optionalPar(self):
localctx = Fortran90Parser.OptionalParContext(self, self._ctx, self.state)
self.enterRule(localctx, 90, self.RULE_optionalPar)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1079
self.dummyArgName()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class NamelistStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def NAMELIST(self):
return self.getToken(Fortran90Parser.NAMELIST, 0)
[docs]
def namelistGroups(self):
return self.getTypedRuleContext(Fortran90Parser.NamelistGroupsContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_namelistStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterNamelistStmt" ):
listener.enterNamelistStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitNamelistStmt" ):
listener.exitNamelistStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNamelistStmt" ):
return visitor.visitNamelistStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def namelistStmt(self):
localctx = Fortran90Parser.NamelistStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 92, self.RULE_namelistStmt)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1081
self.match(Fortran90Parser.NAMELIST)
self.state = 1082
self.namelistGroups(0)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class NamelistGroupsContext(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(Fortran90Parser.DIV)
else:
return self.getToken(Fortran90Parser.DIV, i)
[docs]
def namelistGroupName(self):
return self.getTypedRuleContext(Fortran90Parser.NamelistGroupNameContext,0)
[docs]
def namelistGroupObject(self):
return self.getTypedRuleContext(Fortran90Parser.NamelistGroupObjectContext,0)
[docs]
def namelistGroups(self):
return self.getTypedRuleContext(Fortran90Parser.NamelistGroupsContext,0)
[docs]
def COMMA(self):
return self.getToken(Fortran90Parser.COMMA, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_namelistGroups
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterNamelistGroups" ):
listener.enterNamelistGroups(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitNamelistGroups" ):
listener.exitNamelistGroups(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNamelistGroups" ):
return visitor.visitNamelistGroups(self)
else:
return visitor.visitChildren(self)
[docs]
def namelistGroups(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = Fortran90Parser.NamelistGroupsContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 94
self.enterRecursionRule(localctx, 94, self.RULE_namelistGroups, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1085
self.match(Fortran90Parser.DIV)
self.state = 1086
self.namelistGroupName()
self.state = 1087
self.match(Fortran90Parser.DIV)
self.state = 1088
self.namelistGroupObject()
self._ctx.stop = self._input.LT(-1)
self.state = 1108
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,52,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
self.state = 1106
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,51,self._ctx)
if la_ == 1:
localctx = Fortran90Parser.NamelistGroupsContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_namelistGroups)
self.state = 1090
if not self.precpred(self._ctx, 3):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
self.state = 1091
self.match(Fortran90Parser.DIV)
self.state = 1092
self.namelistGroupName()
self.state = 1093
self.match(Fortran90Parser.DIV)
self.state = 1094
self.namelistGroupObject()
pass
elif la_ == 2:
localctx = Fortran90Parser.NamelistGroupsContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_namelistGroups)
self.state = 1096
if not self.precpred(self._ctx, 2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
self.state = 1097
self.match(Fortran90Parser.COMMA)
self.state = 1098
self.match(Fortran90Parser.DIV)
self.state = 1099
self.namelistGroupName()
self.state = 1100
self.match(Fortran90Parser.DIV)
self.state = 1101
self.namelistGroupObject()
pass
elif la_ == 3:
localctx = Fortran90Parser.NamelistGroupsContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_namelistGroups)
self.state = 1103
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 1104
self.match(Fortran90Parser.COMMA)
self.state = 1105
self.namelistGroupObject()
pass
self.state = 1110
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,52,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class NamelistGroupNameContext(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(Fortran90Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_namelistGroupName
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterNamelistGroupName" ):
listener.enterNamelistGroupName(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitNamelistGroupName" ):
listener.exitNamelistGroupName(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNamelistGroupName" ):
return visitor.visitNamelistGroupName(self)
else:
return visitor.visitChildren(self)
[docs]
def namelistGroupName(self):
localctx = Fortran90Parser.NamelistGroupNameContext(self, self._ctx, self.state)
self.enterRule(localctx, 96, self.RULE_namelistGroupName)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1111
self.match(Fortran90Parser.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 NamelistGroupObjectContext(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(Fortran90Parser.VariableNameContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_namelistGroupObject
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterNamelistGroupObject" ):
listener.enterNamelistGroupObject(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitNamelistGroupObject" ):
listener.exitNamelistGroupObject(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNamelistGroupObject" ):
return visitor.visitNamelistGroupObject(self)
else:
return visitor.visitChildren(self)
[docs]
def namelistGroupObject(self):
localctx = Fortran90Parser.NamelistGroupObjectContext(self, self._ctx, self.state)
self.enterRule(localctx, 98, self.RULE_namelistGroupObject)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1113
self.variableName()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class IntentStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def INTENT(self):
return self.getToken(Fortran90Parser.INTENT, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def intentSpec(self):
return self.getTypedRuleContext(Fortran90Parser.IntentSpecContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def intentParList(self):
return self.getTypedRuleContext(Fortran90Parser.IntentParListContext,0)
[docs]
def DOUBLECOLON(self):
return self.getToken(Fortran90Parser.DOUBLECOLON, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_intentStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIntentStmt" ):
listener.enterIntentStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIntentStmt" ):
listener.exitIntentStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIntentStmt" ):
return visitor.visitIntentStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def intentStmt(self):
localctx = Fortran90Parser.IntentStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 100, self.RULE_intentStmt)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1115
self.match(Fortran90Parser.INTENT)
self.state = 1116
self.match(Fortran90Parser.LPAREN)
self.state = 1117
self.intentSpec()
self.state = 1118
self.match(Fortran90Parser.RPAREN)
self.state = 1120
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.DOUBLECOLON:
self.state = 1119
self.match(Fortran90Parser.DOUBLECOLON)
self.state = 1122
self.intentParList()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class IntentParListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def intentPar(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.IntentParContext)
else:
return self.getTypedRuleContext(Fortran90Parser.IntentParContext,i)
[docs]
def COMMA(self):
return self.getToken(Fortran90Parser.COMMA, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_intentParList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIntentParList" ):
listener.enterIntentParList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIntentParList" ):
listener.exitIntentParList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIntentParList" ):
return visitor.visitIntentParList(self)
else:
return visitor.visitChildren(self)
[docs]
def intentParList(self):
localctx = Fortran90Parser.IntentParListContext(self, self._ctx, self.state)
self.enterRule(localctx, 102, self.RULE_intentParList)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1124
self.intentPar()
self.state = 1125
self.match(Fortran90Parser.COMMA)
self.state = 1126
self.intentPar()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class IntentParContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def dummyArgName(self):
return self.getTypedRuleContext(Fortran90Parser.DummyArgNameContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_intentPar
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIntentPar" ):
listener.enterIntentPar(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIntentPar" ):
listener.exitIntentPar(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIntentPar" ):
return visitor.visitIntentPar(self)
else:
return visitor.visitChildren(self)
[docs]
def intentPar(self):
localctx = Fortran90Parser.IntentParContext(self, self._ctx, self.state)
self.enterRule(localctx, 104, self.RULE_intentPar)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1128
self.dummyArgName()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class DummyArgNameContext(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(Fortran90Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_dummyArgName
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDummyArgName" ):
listener.enterDummyArgName(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDummyArgName" ):
listener.exitDummyArgName(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDummyArgName" ):
return visitor.visitDummyArgName(self)
else:
return visitor.visitChildren(self)
[docs]
def dummyArgName(self):
localctx = Fortran90Parser.DummyArgNameContext(self, self._ctx, self.state)
self.enterRule(localctx, 106, self.RULE_dummyArgName)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1130
self.match(Fortran90Parser.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 IntentSpecContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def IN(self):
return self.getToken(Fortran90Parser.IN, 0)
[docs]
def OUT(self):
return self.getToken(Fortran90Parser.OUT, 0)
[docs]
def INOUT(self):
return self.getToken(Fortran90Parser.INOUT, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_intentSpec
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIntentSpec" ):
listener.enterIntentSpec(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIntentSpec" ):
listener.exitIntentSpec(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIntentSpec" ):
return visitor.visitIntentSpec(self)
else:
return visitor.visitChildren(self)
[docs]
def intentSpec(self):
localctx = Fortran90Parser.IntentSpecContext(self, self._ctx, self.state)
self.enterRule(localctx, 108, self.RULE_intentSpec)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1132
_la = self._input.LA(1)
if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Fortran90Parser.IN) | (1 << Fortran90Parser.OUT) | (1 << Fortran90Parser.INOUT))) != 0)):
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 AllocatableStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ALLOCATABLE(self):
return self.getToken(Fortran90Parser.ALLOCATABLE, 0)
[docs]
def arrayAllocationList(self):
return self.getTypedRuleContext(Fortran90Parser.ArrayAllocationListContext,0)
[docs]
def DOUBLECOLON(self):
return self.getToken(Fortran90Parser.DOUBLECOLON, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_allocatableStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAllocatableStmt" ):
listener.enterAllocatableStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAllocatableStmt" ):
listener.exitAllocatableStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAllocatableStmt" ):
return visitor.visitAllocatableStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def allocatableStmt(self):
localctx = Fortran90Parser.AllocatableStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 110, self.RULE_allocatableStmt)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1134
self.match(Fortran90Parser.ALLOCATABLE)
self.state = 1136
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.DOUBLECOLON:
self.state = 1135
self.match(Fortran90Parser.DOUBLECOLON)
self.state = 1138
self.arrayAllocationList()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ArrayAllocationListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def arrayAllocation(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.ArrayAllocationContext)
else:
return self.getTypedRuleContext(Fortran90Parser.ArrayAllocationContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_arrayAllocationList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterArrayAllocationList" ):
listener.enterArrayAllocationList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitArrayAllocationList" ):
listener.exitArrayAllocationList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitArrayAllocationList" ):
return visitor.visitArrayAllocationList(self)
else:
return visitor.visitChildren(self)
[docs]
def arrayAllocationList(self):
localctx = Fortran90Parser.ArrayAllocationListContext(self, self._ctx, self.state)
self.enterRule(localctx, 112, self.RULE_arrayAllocationList)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1140
self.arrayAllocation()
self.state = 1145
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,55,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 1141
self.match(Fortran90Parser.COMMA)
self.state = 1142
self.arrayAllocation()
self.state = 1147
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,55,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 ArrayAllocationContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def arrayName(self):
return self.getTypedRuleContext(Fortran90Parser.ArrayNameContext,0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def deferredShapeSpecList(self):
return self.getTypedRuleContext(Fortran90Parser.DeferredShapeSpecListContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_arrayAllocation
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterArrayAllocation" ):
listener.enterArrayAllocation(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitArrayAllocation" ):
listener.exitArrayAllocation(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitArrayAllocation" ):
return visitor.visitArrayAllocation(self)
else:
return visitor.visitChildren(self)
[docs]
def arrayAllocation(self):
localctx = Fortran90Parser.ArrayAllocationContext(self, self._ctx, self.state)
self.enterRule(localctx, 114, self.RULE_arrayAllocation)
try:
self.state = 1154
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,56,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1148
self.arrayName()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1149
self.arrayName()
self.state = 1150
self.match(Fortran90Parser.LPAREN)
self.state = 1151
self.deferredShapeSpecList()
self.state = 1152
self.match(Fortran90Parser.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 ArrayNameContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ident(self):
return self.getTypedRuleContext(Fortran90Parser.IdentContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.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 = Fortran90Parser.ArrayNameContext(self, self._ctx, self.state)
self.enterRule(localctx, 116, self.RULE_arrayName)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1156
self.ident()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class AccessStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ACCESSSPEC(self):
return self.getToken(Fortran90Parser.ACCESSSPEC, 0)
[docs]
def accessIdList(self):
return self.getTypedRuleContext(Fortran90Parser.AccessIdListContext,0)
[docs]
def DOUBLECOLON(self):
return self.getToken(Fortran90Parser.DOUBLECOLON, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_accessStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAccessStmt" ):
listener.enterAccessStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAccessStmt" ):
listener.exitAccessStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAccessStmt" ):
return visitor.visitAccessStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def accessStmt(self):
localctx = Fortran90Parser.AccessStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 118, self.RULE_accessStmt)
self._la = 0 # Token type
try:
self.state = 1164
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,58,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1158
self.match(Fortran90Parser.ACCESSSPEC)
self.state = 1160
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.DOUBLECOLON:
self.state = 1159
self.match(Fortran90Parser.DOUBLECOLON)
self.state = 1162
self.accessIdList()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1163
self.match(Fortran90Parser.ACCESSSPEC)
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 AccessIdListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def accessId(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.AccessIdContext)
else:
return self.getTypedRuleContext(Fortran90Parser.AccessIdContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_accessIdList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAccessIdList" ):
listener.enterAccessIdList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAccessIdList" ):
listener.exitAccessIdList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAccessIdList" ):
return visitor.visitAccessIdList(self)
else:
return visitor.visitChildren(self)
[docs]
def accessIdList(self):
localctx = Fortran90Parser.AccessIdListContext(self, self._ctx, self.state)
self.enterRule(localctx, 120, self.RULE_accessIdList)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1166
self.accessId()
self.state = 1171
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,59,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 1167
self.match(Fortran90Parser.COMMA)
self.state = 1168
self.accessId()
self.state = 1173
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,59,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 AccessIdContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def genericName(self):
return self.getTypedRuleContext(Fortran90Parser.GenericNameContext,0)
[docs]
def genericSpec(self):
return self.getTypedRuleContext(Fortran90Parser.GenericSpecContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_accessId
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAccessId" ):
listener.enterAccessId(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAccessId" ):
listener.exitAccessId(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAccessId" ):
return visitor.visitAccessId(self)
else:
return visitor.visitChildren(self)
[docs]
def accessId(self):
localctx = Fortran90Parser.AccessIdContext(self, self._ctx, self.state)
self.enterRule(localctx, 122, self.RULE_accessId)
try:
self.state = 1176
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.NAME]:
self.enterOuterAlt(localctx, 1)
self.state = 1174
self.genericName()
pass
elif token in [Fortran90Parser.OPERATOR, Fortran90Parser.ASSIGNMENT]:
self.enterOuterAlt(localctx, 2)
self.state = 1175
self.genericSpec()
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 GenericNameContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ident(self):
return self.getTypedRuleContext(Fortran90Parser.IdentContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_genericName
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterGenericName" ):
listener.enterGenericName(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitGenericName" ):
listener.exitGenericName(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitGenericName" ):
return visitor.visitGenericName(self)
else:
return visitor.visitChildren(self)
[docs]
def genericName(self):
localctx = Fortran90Parser.GenericNameContext(self, self._ctx, self.state)
self.enterRule(localctx, 124, self.RULE_genericName)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1178
self.ident()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class SaveStmtContext(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(Fortran90Parser.SAVE, 0)
[docs]
def savedEntityList(self):
return self.getTypedRuleContext(Fortran90Parser.SavedEntityListContext,0)
[docs]
def DOUBLECOLON(self):
return self.getToken(Fortran90Parser.DOUBLECOLON, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_saveStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSaveStmt" ):
listener.enterSaveStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSaveStmt" ):
listener.exitSaveStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSaveStmt" ):
return visitor.visitSaveStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def saveStmt(self):
localctx = Fortran90Parser.SaveStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 126, self.RULE_saveStmt)
try:
self.state = 1186
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,61,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1180
self.match(Fortran90Parser.SAVE)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1181
self.match(Fortran90Parser.SAVE)
self.state = 1182
self.savedEntityList()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 1183
self.match(Fortran90Parser.SAVE)
self.state = 1184
self.match(Fortran90Parser.DOUBLECOLON)
self.state = 1185
self.savedEntityList()
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 SavedEntityListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def savedEntity(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.SavedEntityContext)
else:
return self.getTypedRuleContext(Fortran90Parser.SavedEntityContext,i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_savedEntityList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSavedEntityList" ):
listener.enterSavedEntityList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSavedEntityList" ):
listener.exitSavedEntityList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSavedEntityList" ):
return visitor.visitSavedEntityList(self)
else:
return visitor.visitChildren(self)
[docs]
def savedEntityList(self):
localctx = Fortran90Parser.SavedEntityListContext(self, self._ctx, self.state)
self.enterRule(localctx, 128, self.RULE_savedEntityList)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1189
self._errHandler.sync(self)
_alt = 1
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 1188
self.savedEntity()
else:
raise NoViableAltException(self)
self.state = 1191
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,62,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 SavedEntityContext(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(Fortran90Parser.VariableNameContext,0)
[docs]
def savedCommonBlock(self):
return self.getTypedRuleContext(Fortran90Parser.SavedCommonBlockContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_savedEntity
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSavedEntity" ):
listener.enterSavedEntity(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSavedEntity" ):
listener.exitSavedEntity(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSavedEntity" ):
return visitor.visitSavedEntity(self)
else:
return visitor.visitChildren(self)
[docs]
def savedEntity(self):
localctx = Fortran90Parser.SavedEntityContext(self, self._ctx, self.state)
self.enterRule(localctx, 130, self.RULE_savedEntity)
try:
self.state = 1195
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.NAME]:
self.enterOuterAlt(localctx, 1)
self.state = 1193
self.variableName()
pass
elif token in [Fortran90Parser.DIV]:
self.enterOuterAlt(localctx, 2)
self.state = 1194
self.savedCommonBlock()
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 SavedCommonBlockContext(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(Fortran90Parser.DIV)
else:
return self.getToken(Fortran90Parser.DIV, i)
[docs]
def commonBlockName(self):
return self.getTypedRuleContext(Fortran90Parser.CommonBlockNameContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_savedCommonBlock
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSavedCommonBlock" ):
listener.enterSavedCommonBlock(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSavedCommonBlock" ):
listener.exitSavedCommonBlock(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSavedCommonBlock" ):
return visitor.visitSavedCommonBlock(self)
else:
return visitor.visitChildren(self)
[docs]
def savedCommonBlock(self):
localctx = Fortran90Parser.SavedCommonBlockContext(self, self._ctx, self.state)
self.enterRule(localctx, 132, self.RULE_savedCommonBlock)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1197
self.match(Fortran90Parser.DIV)
self.state = 1198
self.commonBlockName()
self.state = 1199
self.match(Fortran90Parser.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 IntrinsicStmtContext(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(Fortran90Parser.INTRINSIC, 0)
[docs]
def intrinsicList(self):
return self.getTypedRuleContext(Fortran90Parser.IntrinsicListContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_intrinsicStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIntrinsicStmt" ):
listener.enterIntrinsicStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIntrinsicStmt" ):
listener.exitIntrinsicStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIntrinsicStmt" ):
return visitor.visitIntrinsicStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def intrinsicStmt(self):
localctx = Fortran90Parser.IntrinsicStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 134, self.RULE_intrinsicStmt)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1201
self.match(Fortran90Parser.INTRINSIC)
self.state = 1202
self.intrinsicList()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class IntrinsicListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def intrinsicProcedureName(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.IntrinsicProcedureNameContext)
else:
return self.getTypedRuleContext(Fortran90Parser.IntrinsicProcedureNameContext,i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_intrinsicList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIntrinsicList" ):
listener.enterIntrinsicList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIntrinsicList" ):
listener.exitIntrinsicList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIntrinsicList" ):
return visitor.visitIntrinsicList(self)
else:
return visitor.visitChildren(self)
[docs]
def intrinsicList(self):
localctx = Fortran90Parser.IntrinsicListContext(self, self._ctx, self.state)
self.enterRule(localctx, 136, self.RULE_intrinsicList)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1205
self._errHandler.sync(self)
_alt = 1
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 1204
self.intrinsicProcedureName()
else:
raise NoViableAltException(self)
self.state = 1207
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,64,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 IntrinsicProcedureNameContext(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(Fortran90Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_intrinsicProcedureName
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIntrinsicProcedureName" ):
listener.enterIntrinsicProcedureName(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIntrinsicProcedureName" ):
listener.exitIntrinsicProcedureName(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIntrinsicProcedureName" ):
return visitor.visitIntrinsicProcedureName(self)
else:
return visitor.visitChildren(self)
[docs]
def intrinsicProcedureName(self):
localctx = Fortran90Parser.IntrinsicProcedureNameContext(self, self._ctx, self.state)
self.enterRule(localctx, 138, self.RULE_intrinsicProcedureName)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1209
self.match(Fortran90Parser.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 ExternalStmtContext(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(Fortran90Parser.EXTERNAL, 0)
[docs]
def externalNameList(self):
return self.getTypedRuleContext(Fortran90Parser.ExternalNameListContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_externalStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterExternalStmt" ):
listener.enterExternalStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitExternalStmt" ):
listener.exitExternalStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitExternalStmt" ):
return visitor.visitExternalStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def externalStmt(self):
localctx = Fortran90Parser.ExternalStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 140, self.RULE_externalStmt)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1211
self.match(Fortran90Parser.EXTERNAL)
self.state = 1212
self.externalNameList()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ExternalNameListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def externalName(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.ExternalNameContext)
else:
return self.getTypedRuleContext(Fortran90Parser.ExternalNameContext,i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_externalNameList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterExternalNameList" ):
listener.enterExternalNameList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitExternalNameList" ):
listener.exitExternalNameList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitExternalNameList" ):
return visitor.visitExternalNameList(self)
else:
return visitor.visitChildren(self)
[docs]
def externalNameList(self):
localctx = Fortran90Parser.ExternalNameListContext(self, self._ctx, self.state)
self.enterRule(localctx, 142, self.RULE_externalNameList)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1215
self._errHandler.sync(self)
_alt = 1
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 1214
self.externalName()
else:
raise NoViableAltException(self)
self.state = 1217
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,65,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 ExternalNameContext(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(Fortran90Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_externalName
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterExternalName" ):
listener.enterExternalName(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitExternalName" ):
listener.exitExternalName(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitExternalName" ):
return visitor.visitExternalName(self)
else:
return visitor.visitChildren(self)
[docs]
def externalName(self):
localctx = Fortran90Parser.ExternalNameContext(self, self._ctx, self.state)
self.enterRule(localctx, 144, self.RULE_externalName)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1219
self.match(Fortran90Parser.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 EquivalenceStmtContext(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(Fortran90Parser.EQUIVALENCE, 0)
[docs]
def equivalenceSetList(self):
return self.getTypedRuleContext(Fortran90Parser.EquivalenceSetListContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_equivalenceStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEquivalenceStmt" ):
listener.enterEquivalenceStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEquivalenceStmt" ):
listener.exitEquivalenceStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEquivalenceStmt" ):
return visitor.visitEquivalenceStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def equivalenceStmt(self):
localctx = Fortran90Parser.EquivalenceStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 146, self.RULE_equivalenceStmt)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1221
self.match(Fortran90Parser.EQUIVALENCE)
self.state = 1222
self.equivalenceSetList()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class EquivalenceSetListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def equivalenceSet(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.EquivalenceSetContext)
else:
return self.getTypedRuleContext(Fortran90Parser.EquivalenceSetContext,i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_equivalenceSetList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEquivalenceSetList" ):
listener.enterEquivalenceSetList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEquivalenceSetList" ):
listener.exitEquivalenceSetList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEquivalenceSetList" ):
return visitor.visitEquivalenceSetList(self)
else:
return visitor.visitChildren(self)
[docs]
def equivalenceSetList(self):
localctx = Fortran90Parser.EquivalenceSetListContext(self, self._ctx, self.state)
self.enterRule(localctx, 148, self.RULE_equivalenceSetList)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1225
self._errHandler.sync(self)
_alt = 1
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 1224
self.equivalenceSet()
else:
raise NoViableAltException(self)
self.state = 1227
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,66,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 EquivalenceSetContext(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(Fortran90Parser.LPAREN, 0)
[docs]
def equivalenceObject(self):
return self.getTypedRuleContext(Fortran90Parser.EquivalenceObjectContext,0)
[docs]
def COMMA(self):
return self.getToken(Fortran90Parser.COMMA, 0)
[docs]
def equivalenceObjectList(self):
return self.getTypedRuleContext(Fortran90Parser.EquivalenceObjectListContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_equivalenceSet
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEquivalenceSet" ):
listener.enterEquivalenceSet(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEquivalenceSet" ):
listener.exitEquivalenceSet(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEquivalenceSet" ):
return visitor.visitEquivalenceSet(self)
else:
return visitor.visitChildren(self)
[docs]
def equivalenceSet(self):
localctx = Fortran90Parser.EquivalenceSetContext(self, self._ctx, self.state)
self.enterRule(localctx, 150, self.RULE_equivalenceSet)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1229
self.match(Fortran90Parser.LPAREN)
self.state = 1230
self.equivalenceObject()
self.state = 1231
self.match(Fortran90Parser.COMMA)
self.state = 1232
self.equivalenceObjectList()
self.state = 1233
self.match(Fortran90Parser.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 EquivalenceObjectContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def variable(self):
return self.getTypedRuleContext(Fortran90Parser.VariableContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_equivalenceObject
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEquivalenceObject" ):
listener.enterEquivalenceObject(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEquivalenceObject" ):
listener.exitEquivalenceObject(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEquivalenceObject" ):
return visitor.visitEquivalenceObject(self)
else:
return visitor.visitChildren(self)
[docs]
def equivalenceObject(self):
localctx = Fortran90Parser.EquivalenceObjectContext(self, self._ctx, self.state)
self.enterRule(localctx, 152, self.RULE_equivalenceObject)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1235
self.variable()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class EquivalenceObjectListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def equivalenceObject(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.EquivalenceObjectContext)
else:
return self.getTypedRuleContext(Fortran90Parser.EquivalenceObjectContext,i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_equivalenceObjectList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEquivalenceObjectList" ):
listener.enterEquivalenceObjectList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEquivalenceObjectList" ):
listener.exitEquivalenceObjectList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEquivalenceObjectList" ):
return visitor.visitEquivalenceObjectList(self)
else:
return visitor.visitChildren(self)
[docs]
def equivalenceObjectList(self):
localctx = Fortran90Parser.EquivalenceObjectListContext(self, self._ctx, self.state)
self.enterRule(localctx, 154, self.RULE_equivalenceObjectList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1238
self._errHandler.sync(self)
_la = self._input.LA(1)
while True:
self.state = 1237
self.equivalenceObject()
self.state = 1240
self._errHandler.sync(self)
_la = self._input.LA(1)
if not (_la==Fortran90Parser.NAME):
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 DimensionStmtContext(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(Fortran90Parser.DIMENSION, 0)
[docs]
def arrayDeclaratorList(self):
return self.getTypedRuleContext(Fortran90Parser.ArrayDeclaratorListContext,0)
[docs]
def DOUBLECOLON(self):
return self.getToken(Fortran90Parser.DOUBLECOLON, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_dimensionStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDimensionStmt" ):
listener.enterDimensionStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDimensionStmt" ):
listener.exitDimensionStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDimensionStmt" ):
return visitor.visitDimensionStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def dimensionStmt(self):
localctx = Fortran90Parser.DimensionStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 156, self.RULE_dimensionStmt)
try:
self.state = 1247
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,68,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1242
self.match(Fortran90Parser.DIMENSION)
self.state = 1243
self.arrayDeclaratorList()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1244
self.match(Fortran90Parser.DIMENSION)
self.state = 1245
self.match(Fortran90Parser.DOUBLECOLON)
self.state = 1246
self.arrayDeclaratorList()
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 ArrayDeclaratorListContext(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(Fortran90Parser.ArrayDeclaratorContext)
else:
return self.getTypedRuleContext(Fortran90Parser.ArrayDeclaratorContext,i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_arrayDeclaratorList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterArrayDeclaratorList" ):
listener.enterArrayDeclaratorList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitArrayDeclaratorList" ):
listener.exitArrayDeclaratorList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitArrayDeclaratorList" ):
return visitor.visitArrayDeclaratorList(self)
else:
return visitor.visitChildren(self)
[docs]
def arrayDeclaratorList(self):
localctx = Fortran90Parser.ArrayDeclaratorListContext(self, self._ctx, self.state)
self.enterRule(localctx, 158, self.RULE_arrayDeclaratorList)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1250
self._errHandler.sync(self)
_alt = 1
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 1249
self.arrayDeclarator()
else:
raise NoViableAltException(self)
self.state = 1252
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,69,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 CommonStmtContext(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(Fortran90Parser.COMMON, 0)
[docs]
def comlist(self):
return self.getTypedRuleContext(Fortran90Parser.ComlistContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_commonStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCommonStmt" ):
listener.enterCommonStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCommonStmt" ):
listener.exitCommonStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCommonStmt" ):
return visitor.visitCommonStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def commonStmt(self):
localctx = Fortran90Parser.CommonStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 160, self.RULE_commonStmt)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1254
self.match(Fortran90Parser.COMMON)
self.state = 1255
self.comlist(0)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ComlistContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def commonBlockObject(self):
return self.getTypedRuleContext(Fortran90Parser.CommonBlockObjectContext,0)
[docs]
def comblock(self):
return self.getTypedRuleContext(Fortran90Parser.ComblockContext,0)
[docs]
def comlist(self):
return self.getTypedRuleContext(Fortran90Parser.ComlistContext,0)
[docs]
def COMMA(self):
return self.getToken(Fortran90Parser.COMMA, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_comlist
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterComlist" ):
listener.enterComlist(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitComlist" ):
listener.exitComlist(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitComlist" ):
return visitor.visitComlist(self)
else:
return visitor.visitChildren(self)
[docs]
def comlist(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = Fortran90Parser.ComlistContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 162
self.enterRecursionRule(localctx, 162, self.RULE_comlist, _p)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1259
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.DIV:
self.state = 1258
self.comblock()
self.state = 1261
self.commonBlockObject()
self._ctx.stop = self._input.LT(-1)
self.state = 1275
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,73,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
self.state = 1273
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,72,self._ctx)
if la_ == 1:
localctx = Fortran90Parser.ComlistContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_comlist)
self.state = 1263
if not self.precpred(self._ctx, 2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
self.state = 1264
self.match(Fortran90Parser.COMMA)
self.state = 1266
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.DIV:
self.state = 1265
self.comblock()
self.state = 1268
self.commonBlockObject()
pass
elif la_ == 2:
localctx = Fortran90Parser.ComlistContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_comlist)
self.state = 1269
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 1270
self.comblock()
self.state = 1271
self.commonBlockObject()
pass
self.state = 1277
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,73,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class CommonBlockObjectContext(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(Fortran90Parser.VariableNameContext,0)
[docs]
def arrayDeclarator(self):
return self.getTypedRuleContext(Fortran90Parser.ArrayDeclaratorContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_commonBlockObject
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCommonBlockObject" ):
listener.enterCommonBlockObject(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCommonBlockObject" ):
listener.exitCommonBlockObject(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCommonBlockObject" ):
return visitor.visitCommonBlockObject(self)
else:
return visitor.visitChildren(self)
[docs]
def commonBlockObject(self):
localctx = Fortran90Parser.CommonBlockObjectContext(self, self._ctx, self.state)
self.enterRule(localctx, 164, self.RULE_commonBlockObject)
try:
self.state = 1280
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,74,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1278
self.variableName()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1279
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 ArrayDeclaratorContext(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(Fortran90Parser.VariableNameContext,0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def arraySpec(self):
return self.getTypedRuleContext(Fortran90Parser.ArraySpecContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.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 = Fortran90Parser.ArrayDeclaratorContext(self, self._ctx, self.state)
self.enterRule(localctx, 166, self.RULE_arrayDeclarator)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1282
self.variableName()
self.state = 1283
self.match(Fortran90Parser.LPAREN)
self.state = 1284
self.arraySpec()
self.state = 1285
self.match(Fortran90Parser.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 ComblockContext(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(Fortran90Parser.DIV)
else:
return self.getToken(Fortran90Parser.DIV, i)
[docs]
def SPOFF(self):
return self.getToken(Fortran90Parser.SPOFF, 0)
[docs]
def SPON(self):
return self.getToken(Fortran90Parser.SPON, 0)
[docs]
def commonBlockName(self):
return self.getTypedRuleContext(Fortran90Parser.CommonBlockNameContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_comblock
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterComblock" ):
listener.enterComblock(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitComblock" ):
listener.exitComblock(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitComblock" ):
return visitor.visitComblock(self)
else:
return visitor.visitChildren(self)
[docs]
def comblock(self):
localctx = Fortran90Parser.ComblockContext(self, self._ctx, self.state)
self.enterRule(localctx, 168, self.RULE_comblock)
try:
self.state = 1295
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,75,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1287
self.match(Fortran90Parser.DIV)
self.state = 1288
self.match(Fortran90Parser.SPOFF)
self.state = 1289
self.match(Fortran90Parser.DIV)
self.state = 1290
self.match(Fortran90Parser.SPON)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1291
self.match(Fortran90Parser.DIV)
self.state = 1292
self.commonBlockName()
self.state = 1293
self.match(Fortran90Parser.DIV)
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 CommonBlockNameContext(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(Fortran90Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_commonBlockName
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCommonBlockName" ):
listener.enterCommonBlockName(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCommonBlockName" ):
listener.exitCommonBlockName(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCommonBlockName" ):
return visitor.visitCommonBlockName(self)
else:
return visitor.visitChildren(self)
[docs]
def commonBlockName(self):
localctx = Fortran90Parser.CommonBlockNameContext(self, self._ctx, self.state)
self.enterRule(localctx, 170, self.RULE_commonBlockName)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1297
self.match(Fortran90Parser.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 TypeDeclarationStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def typeSpec(self):
return self.getTypedRuleContext(Fortran90Parser.TypeSpecContext,0)
[docs]
def entityDeclList(self):
return self.getTypedRuleContext(Fortran90Parser.EntityDeclListContext,0)
[docs]
def DOUBLECOLON(self):
return self.getToken(Fortran90Parser.DOUBLECOLON, 0)
[docs]
def attrSpecSeq(self):
return self.getTypedRuleContext(Fortran90Parser.AttrSpecSeqContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_typeDeclarationStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTypeDeclarationStmt" ):
listener.enterTypeDeclarationStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTypeDeclarationStmt" ):
listener.exitTypeDeclarationStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTypeDeclarationStmt" ):
return visitor.visitTypeDeclarationStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def typeDeclarationStmt(self):
localctx = Fortran90Parser.TypeDeclarationStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 172, self.RULE_typeDeclarationStmt)
self._la = 0 # Token type
try:
self.state = 1309
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,77,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1299
self.typeSpec()
self.state = 1300
self.entityDeclList()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1302
self.typeSpec()
self.state = 1304
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.COMMA:
self.state = 1303
self.attrSpecSeq(0)
self.state = 1306
self.match(Fortran90Parser.DOUBLECOLON)
self.state = 1307
self.entityDeclList()
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 AttrSpecSeqContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def COMMA(self):
return self.getToken(Fortran90Parser.COMMA, 0)
[docs]
def attrSpec(self):
return self.getTypedRuleContext(Fortran90Parser.AttrSpecContext,0)
[docs]
def attrSpecSeq(self):
return self.getTypedRuleContext(Fortran90Parser.AttrSpecSeqContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_attrSpecSeq
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAttrSpecSeq" ):
listener.enterAttrSpecSeq(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAttrSpecSeq" ):
listener.exitAttrSpecSeq(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAttrSpecSeq" ):
return visitor.visitAttrSpecSeq(self)
else:
return visitor.visitChildren(self)
[docs]
def attrSpecSeq(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = Fortran90Parser.AttrSpecSeqContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 174
self.enterRecursionRule(localctx, 174, self.RULE_attrSpecSeq, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1312
self.match(Fortran90Parser.COMMA)
self.state = 1313
self.attrSpec()
self._ctx.stop = self._input.LT(-1)
self.state = 1320
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,78,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = Fortran90Parser.AttrSpecSeqContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_attrSpecSeq)
self.state = 1315
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 1316
self.match(Fortran90Parser.COMMA)
self.state = 1317
self.attrSpec()
self.state = 1322
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,78,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class AttrSpecContext(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(Fortran90Parser.PARAMETER, 0)
[docs]
def ACCESSSPEC(self):
return self.getToken(Fortran90Parser.ACCESSSPEC, 0)
[docs]
def ALLOCATABLE(self):
return self.getToken(Fortran90Parser.ALLOCATABLE, 0)
[docs]
def DIMENSION(self):
return self.getToken(Fortran90Parser.DIMENSION, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def arraySpec(self):
return self.getTypedRuleContext(Fortran90Parser.ArraySpecContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def EXTERNAL(self):
return self.getToken(Fortran90Parser.EXTERNAL, 0)
[docs]
def INTENT(self):
return self.getToken(Fortran90Parser.INTENT, 0)
[docs]
def intentSpec(self):
return self.getTypedRuleContext(Fortran90Parser.IntentSpecContext,0)
[docs]
def INTRINSIC(self):
return self.getToken(Fortran90Parser.INTRINSIC, 0)
[docs]
def OPTIONAL(self):
return self.getToken(Fortran90Parser.OPTIONAL, 0)
[docs]
def POINTER(self):
return self.getToken(Fortran90Parser.POINTER, 0)
[docs]
def SAVE(self):
return self.getToken(Fortran90Parser.SAVE, 0)
[docs]
def TARGET(self):
return self.getToken(Fortran90Parser.TARGET, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_attrSpec
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAttrSpec" ):
listener.enterAttrSpec(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAttrSpec" ):
listener.exitAttrSpec(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAttrSpec" ):
return visitor.visitAttrSpec(self)
else:
return visitor.visitChildren(self)
[docs]
def attrSpec(self):
localctx = Fortran90Parser.AttrSpecContext(self, self._ctx, self.state)
self.enterRule(localctx, 176, self.RULE_attrSpec)
try:
self.state = 1342
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.PARAMETER]:
self.enterOuterAlt(localctx, 1)
self.state = 1323
self.match(Fortran90Parser.PARAMETER)
pass
elif token in [Fortran90Parser.ACCESSSPEC]:
self.enterOuterAlt(localctx, 2)
self.state = 1324
self.match(Fortran90Parser.ACCESSSPEC)
pass
elif token in [Fortran90Parser.ALLOCATABLE]:
self.enterOuterAlt(localctx, 3)
self.state = 1325
self.match(Fortran90Parser.ALLOCATABLE)
pass
elif token in [Fortran90Parser.DIMENSION]:
self.enterOuterAlt(localctx, 4)
self.state = 1326
self.match(Fortran90Parser.DIMENSION)
self.state = 1327
self.match(Fortran90Parser.LPAREN)
self.state = 1328
self.arraySpec()
self.state = 1329
self.match(Fortran90Parser.RPAREN)
pass
elif token in [Fortran90Parser.EXTERNAL]:
self.enterOuterAlt(localctx, 5)
self.state = 1331
self.match(Fortran90Parser.EXTERNAL)
pass
elif token in [Fortran90Parser.INTENT]:
self.enterOuterAlt(localctx, 6)
self.state = 1332
self.match(Fortran90Parser.INTENT)
self.state = 1333
self.match(Fortran90Parser.LPAREN)
self.state = 1334
self.intentSpec()
self.state = 1335
self.match(Fortran90Parser.RPAREN)
pass
elif token in [Fortran90Parser.INTRINSIC]:
self.enterOuterAlt(localctx, 7)
self.state = 1337
self.match(Fortran90Parser.INTRINSIC)
pass
elif token in [Fortran90Parser.OPTIONAL]:
self.enterOuterAlt(localctx, 8)
self.state = 1338
self.match(Fortran90Parser.OPTIONAL)
pass
elif token in [Fortran90Parser.POINTER]:
self.enterOuterAlt(localctx, 9)
self.state = 1339
self.match(Fortran90Parser.POINTER)
pass
elif token in [Fortran90Parser.SAVE]:
self.enterOuterAlt(localctx, 10)
self.state = 1340
self.match(Fortran90Parser.SAVE)
pass
elif token in [Fortran90Parser.TARGET]:
self.enterOuterAlt(localctx, 11)
self.state = 1341
self.match(Fortran90Parser.TARGET)
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 EntityDeclListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def entityDecl(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.EntityDeclContext)
else:
return self.getTypedRuleContext(Fortran90Parser.EntityDeclContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_entityDeclList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEntityDeclList" ):
listener.enterEntityDeclList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEntityDeclList" ):
listener.exitEntityDeclList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEntityDeclList" ):
return visitor.visitEntityDeclList(self)
else:
return visitor.visitChildren(self)
[docs]
def entityDeclList(self):
localctx = Fortran90Parser.EntityDeclListContext(self, self._ctx, self.state)
self.enterRule(localctx, 178, self.RULE_entityDeclList)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1344
self.entityDecl()
self.state = 1349
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,80,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 1345
self.match(Fortran90Parser.COMMA)
self.state = 1346
self.entityDecl()
self.state = 1351
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,80,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 EntityDeclContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def objectName(self):
return self.getTypedRuleContext(Fortran90Parser.ObjectNameContext,0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def arraySpec(self):
return self.getTypedRuleContext(Fortran90Parser.ArraySpecContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def STAR(self):
return self.getToken(Fortran90Parser.STAR, 0)
[docs]
def charLength(self):
return self.getTypedRuleContext(Fortran90Parser.CharLengthContext,0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran90Parser.ASSIGN, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_entityDecl
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEntityDecl" ):
listener.enterEntityDecl(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEntityDecl" ):
listener.exitEntityDecl(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEntityDecl" ):
return visitor.visitEntityDecl(self)
else:
return visitor.visitChildren(self)
[docs]
def entityDecl(self):
localctx = Fortran90Parser.EntityDeclContext(self, self._ctx, self.state)
self.enterRule(localctx, 180, self.RULE_entityDecl)
try:
self.state = 1395
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,81,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1352
self.objectName()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1353
self.objectName()
self.state = 1354
self.match(Fortran90Parser.LPAREN)
self.state = 1355
self.arraySpec()
self.state = 1356
self.match(Fortran90Parser.RPAREN)
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 1358
self.objectName()
self.state = 1359
self.match(Fortran90Parser.STAR)
self.state = 1360
self.charLength()
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 1362
self.objectName()
self.state = 1363
self.match(Fortran90Parser.LPAREN)
self.state = 1364
self.arraySpec()
self.state = 1365
self.match(Fortran90Parser.RPAREN)
self.state = 1366
self.match(Fortran90Parser.STAR)
self.state = 1367
self.charLength()
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 1369
self.objectName()
self.state = 1370
self.match(Fortran90Parser.ASSIGN)
self.state = 1371
self.expression(0)
pass
elif la_ == 6:
self.enterOuterAlt(localctx, 6)
self.state = 1373
self.objectName()
self.state = 1374
self.match(Fortran90Parser.LPAREN)
self.state = 1375
self.arraySpec()
self.state = 1376
self.match(Fortran90Parser.RPAREN)
self.state = 1377
self.match(Fortran90Parser.ASSIGN)
self.state = 1378
self.expression(0)
pass
elif la_ == 7:
self.enterOuterAlt(localctx, 7)
self.state = 1380
self.objectName()
self.state = 1381
self.match(Fortran90Parser.STAR)
self.state = 1382
self.charLength()
self.state = 1383
self.match(Fortran90Parser.ASSIGN)
self.state = 1384
self.expression(0)
pass
elif la_ == 8:
self.enterOuterAlt(localctx, 8)
self.state = 1386
self.objectName()
self.state = 1387
self.match(Fortran90Parser.STAR)
self.state = 1388
self.charLength()
self.state = 1389
self.match(Fortran90Parser.LPAREN)
self.state = 1390
self.arraySpec()
self.state = 1391
self.match(Fortran90Parser.RPAREN)
self.state = 1392
self.match(Fortran90Parser.ASSIGN)
self.state = 1393
self.expression(0)
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 ObjectNameContext(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(Fortran90Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_objectName
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterObjectName" ):
listener.enterObjectName(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitObjectName" ):
listener.exitObjectName(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitObjectName" ):
return visitor.visitObjectName(self)
else:
return visitor.visitChildren(self)
[docs]
def objectName(self):
localctx = Fortran90Parser.ObjectNameContext(self, self._ctx, self.state)
self.enterRule(localctx, 182, self.RULE_objectName)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1397
self.match(Fortran90Parser.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 ArraySpecContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def explicitShapeSpecList(self):
return self.getTypedRuleContext(Fortran90Parser.ExplicitShapeSpecListContext,0)
[docs]
def assumedSizeSpec(self):
return self.getTypedRuleContext(Fortran90Parser.AssumedSizeSpecContext,0)
[docs]
def assumedShapeSpecList(self):
return self.getTypedRuleContext(Fortran90Parser.AssumedShapeSpecListContext,0)
[docs]
def deferredShapeSpecList(self):
return self.getTypedRuleContext(Fortran90Parser.DeferredShapeSpecListContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_arraySpec
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterArraySpec" ):
listener.enterArraySpec(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitArraySpec" ):
listener.exitArraySpec(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitArraySpec" ):
return visitor.visitArraySpec(self)
else:
return visitor.visitChildren(self)
[docs]
def arraySpec(self):
localctx = Fortran90Parser.ArraySpecContext(self, self._ctx, self.state)
self.enterRule(localctx, 184, self.RULE_arraySpec)
try:
self.state = 1403
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,82,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1399
self.explicitShapeSpecList()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1400
self.assumedSizeSpec()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 1401
self.assumedShapeSpecList(0)
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 1402
self.deferredShapeSpecList()
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 AssumedShapeSpecListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def lowerBound(self):
return self.getTypedRuleContext(Fortran90Parser.LowerBoundContext,0)
[docs]
def COLON(self):
return self.getToken(Fortran90Parser.COLON, 0)
[docs]
def deferredShapeSpecList(self):
return self.getTypedRuleContext(Fortran90Parser.DeferredShapeSpecListContext,0)
[docs]
def COMMA(self):
return self.getToken(Fortran90Parser.COMMA, 0)
[docs]
def assumedShapeSpecList(self):
return self.getTypedRuleContext(Fortran90Parser.AssumedShapeSpecListContext,0)
[docs]
def assumedShapeSpec(self):
return self.getTypedRuleContext(Fortran90Parser.AssumedShapeSpecContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_assumedShapeSpecList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAssumedShapeSpecList" ):
listener.enterAssumedShapeSpecList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAssumedShapeSpecList" ):
listener.exitAssumedShapeSpecList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAssumedShapeSpecList" ):
return visitor.visitAssumedShapeSpecList(self)
else:
return visitor.visitChildren(self)
[docs]
def assumedShapeSpecList(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = Fortran90Parser.AssumedShapeSpecListContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 186
self.enterRecursionRule(localctx, 186, self.RULE_assumedShapeSpecList, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1414
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.DOP, Fortran90Parser.REAL, Fortran90Parser.SIZE, Fortran90Parser.LPAREN, Fortran90Parser.MINUS, Fortran90Parser.PLUS, Fortran90Parser.LNOT, Fortran90Parser.TRUE, Fortran90Parser.FALSE, Fortran90Parser.OBRACKETSLASH, Fortran90Parser.SCON, Fortran90Parser.RDCON, Fortran90Parser.ICON, Fortran90Parser.NAME]:
self.state = 1406
self.lowerBound()
self.state = 1407
self.match(Fortran90Parser.COLON)
pass
elif token in [Fortran90Parser.COLON]:
self.state = 1409
self.deferredShapeSpecList()
self.state = 1410
self.match(Fortran90Parser.COMMA)
self.state = 1411
self.lowerBound()
self.state = 1412
self.match(Fortran90Parser.COLON)
pass
else:
raise NoViableAltException(self)
self._ctx.stop = self._input.LT(-1)
self.state = 1421
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,84,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = Fortran90Parser.AssumedShapeSpecListContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_assumedShapeSpecList)
self.state = 1416
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 1417
self.match(Fortran90Parser.COMMA)
self.state = 1418
self.assumedShapeSpec()
self.state = 1423
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,84,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class AssumedShapeSpecContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def lowerBound(self):
return self.getTypedRuleContext(Fortran90Parser.LowerBoundContext,0)
[docs]
def COLON(self):
return self.getToken(Fortran90Parser.COLON, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_assumedShapeSpec
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAssumedShapeSpec" ):
listener.enterAssumedShapeSpec(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAssumedShapeSpec" ):
listener.exitAssumedShapeSpec(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAssumedShapeSpec" ):
return visitor.visitAssumedShapeSpec(self)
else:
return visitor.visitChildren(self)
[docs]
def assumedShapeSpec(self):
localctx = Fortran90Parser.AssumedShapeSpecContext(self, self._ctx, self.state)
self.enterRule(localctx, 188, self.RULE_assumedShapeSpec)
try:
self.state = 1428
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.DOP, Fortran90Parser.REAL, Fortran90Parser.SIZE, Fortran90Parser.LPAREN, Fortran90Parser.MINUS, Fortran90Parser.PLUS, Fortran90Parser.LNOT, Fortran90Parser.TRUE, Fortran90Parser.FALSE, Fortran90Parser.OBRACKETSLASH, Fortran90Parser.SCON, Fortran90Parser.RDCON, Fortran90Parser.ICON, Fortran90Parser.NAME]:
self.enterOuterAlt(localctx, 1)
self.state = 1424
self.lowerBound()
self.state = 1425
self.match(Fortran90Parser.COLON)
pass
elif token in [Fortran90Parser.COLON]:
self.enterOuterAlt(localctx, 2)
self.state = 1427
self.match(Fortran90Parser.COLON)
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 AssumedSizeSpecContext(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(Fortran90Parser.STAR, 0)
[docs]
def lowerBound(self):
return self.getTypedRuleContext(Fortran90Parser.LowerBoundContext,0)
[docs]
def COLON(self):
return self.getToken(Fortran90Parser.COLON, 0)
[docs]
def explicitShapeSpecList(self):
return self.getTypedRuleContext(Fortran90Parser.ExplicitShapeSpecListContext,0)
[docs]
def COMMA(self):
return self.getToken(Fortran90Parser.COMMA, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_assumedSizeSpec
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAssumedSizeSpec" ):
listener.enterAssumedSizeSpec(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAssumedSizeSpec" ):
listener.exitAssumedSizeSpec(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAssumedSizeSpec" ):
return visitor.visitAssumedSizeSpec(self)
else:
return visitor.visitChildren(self)
[docs]
def assumedSizeSpec(self):
localctx = Fortran90Parser.AssumedSizeSpecContext(self, self._ctx, self.state)
self.enterRule(localctx, 190, self.RULE_assumedSizeSpec)
try:
self.state = 1445
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,86,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1430
self.match(Fortran90Parser.STAR)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1431
self.lowerBound()
self.state = 1432
self.match(Fortran90Parser.COLON)
self.state = 1433
self.match(Fortran90Parser.STAR)
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 1435
self.explicitShapeSpecList()
self.state = 1436
self.match(Fortran90Parser.COMMA)
self.state = 1437
self.match(Fortran90Parser.STAR)
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 1439
self.explicitShapeSpecList()
self.state = 1440
self.match(Fortran90Parser.COMMA)
self.state = 1441
self.lowerBound()
self.state = 1442
self.match(Fortran90Parser.COLON)
self.state = 1443
self.match(Fortran90Parser.STAR)
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 InterfaceBlockContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def interfaceStmt(self):
return self.getTypedRuleContext(Fortran90Parser.InterfaceStmtContext,0)
[docs]
def interfaceBlockBody(self):
return self.getTypedRuleContext(Fortran90Parser.InterfaceBlockBodyContext,0)
[docs]
def endInterfaceStmt(self):
return self.getTypedRuleContext(Fortran90Parser.EndInterfaceStmtContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_interfaceBlock
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterInterfaceBlock" ):
listener.enterInterfaceBlock(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitInterfaceBlock" ):
listener.exitInterfaceBlock(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitInterfaceBlock" ):
return visitor.visitInterfaceBlock(self)
else:
return visitor.visitChildren(self)
[docs]
def interfaceBlock(self):
localctx = Fortran90Parser.InterfaceBlockContext(self, self._ctx, self.state)
self.enterRule(localctx, 192, self.RULE_interfaceBlock)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1447
self.interfaceStmt()
self.state = 1448
self.interfaceBlockBody(0)
self.state = 1449
self.endInterfaceStmt()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class EndInterfaceStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ENDINTERFACE(self):
return self.getToken(Fortran90Parser.ENDINTERFACE, 0)
[docs]
def END(self):
return self.getToken(Fortran90Parser.END, 0)
[docs]
def INTERFACE(self):
return self.getToken(Fortran90Parser.INTERFACE, 0)
[docs]
def NAME(self):
return self.getToken(Fortran90Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_endInterfaceStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEndInterfaceStmt" ):
listener.enterEndInterfaceStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEndInterfaceStmt" ):
listener.exitEndInterfaceStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEndInterfaceStmt" ):
return visitor.visitEndInterfaceStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def endInterfaceStmt(self):
localctx = Fortran90Parser.EndInterfaceStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 194, self.RULE_endInterfaceStmt)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1454
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.ENDINTERFACE]:
self.state = 1451
self.match(Fortran90Parser.ENDINTERFACE)
pass
elif token in [Fortran90Parser.END]:
self.state = 1452
self.match(Fortran90Parser.END)
self.state = 1453
self.match(Fortran90Parser.INTERFACE)
pass
else:
raise NoViableAltException(self)
self.state = 1457
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,88,self._ctx)
if la_ == 1:
self.state = 1456
self.match(Fortran90Parser.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 InterfaceStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def INTERFACE(self):
return self.getToken(Fortran90Parser.INTERFACE, 0)
[docs]
def NAME(self):
return self.getToken(Fortran90Parser.NAME, 0)
[docs]
def genericSpec(self):
return self.getTypedRuleContext(Fortran90Parser.GenericSpecContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_interfaceStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterInterfaceStmt" ):
listener.enterInterfaceStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitInterfaceStmt" ):
listener.exitInterfaceStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitInterfaceStmt" ):
return visitor.visitInterfaceStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def interfaceStmt(self):
localctx = Fortran90Parser.InterfaceStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 196, self.RULE_interfaceStmt)
try:
self.state = 1464
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,89,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1459
self.match(Fortran90Parser.INTERFACE)
self.state = 1460
self.match(Fortran90Parser.NAME)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1461
self.match(Fortran90Parser.INTERFACE)
self.state = 1462
self.genericSpec()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 1463
self.match(Fortran90Parser.INTERFACE)
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 GenericSpecContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def OPERATOR(self):
return self.getToken(Fortran90Parser.OPERATOR, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def definedOperator(self):
return self.getTypedRuleContext(Fortran90Parser.DefinedOperatorContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def ASSIGNMENT(self):
return self.getToken(Fortran90Parser.ASSIGNMENT, 0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran90Parser.ASSIGN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_genericSpec
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterGenericSpec" ):
listener.enterGenericSpec(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitGenericSpec" ):
listener.exitGenericSpec(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitGenericSpec" ):
return visitor.visitGenericSpec(self)
else:
return visitor.visitChildren(self)
[docs]
def genericSpec(self):
localctx = Fortran90Parser.GenericSpecContext(self, self._ctx, self.state)
self.enterRule(localctx, 198, self.RULE_genericSpec)
try:
self.state = 1475
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.OPERATOR]:
self.enterOuterAlt(localctx, 1)
self.state = 1466
self.match(Fortran90Parser.OPERATOR)
self.state = 1467
self.match(Fortran90Parser.LPAREN)
self.state = 1468
self.definedOperator()
self.state = 1469
self.match(Fortran90Parser.RPAREN)
pass
elif token in [Fortran90Parser.ASSIGNMENT]:
self.enterOuterAlt(localctx, 2)
self.state = 1471
self.match(Fortran90Parser.ASSIGNMENT)
self.state = 1472
self.match(Fortran90Parser.LPAREN)
self.state = 1473
self.match(Fortran90Parser.ASSIGN)
self.state = 1474
self.match(Fortran90Parser.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 DefinedOperatorContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def DOP(self):
return self.getToken(Fortran90Parser.DOP, 0)
[docs]
def POWER(self):
return self.getToken(Fortran90Parser.POWER, 0)
[docs]
def STAR(self):
return self.getToken(Fortran90Parser.STAR, 0)
[docs]
def PLUS(self):
return self.getToken(Fortran90Parser.PLUS, 0)
[docs]
def MINUS(self):
return self.getToken(Fortran90Parser.MINUS, 0)
[docs]
def LT(self):
return self.getToken(Fortran90Parser.LT, 0)
[docs]
def LE(self):
return self.getToken(Fortran90Parser.LE, 0)
[docs]
def EQ(self):
return self.getToken(Fortran90Parser.EQ, 0)
[docs]
def NE(self):
return self.getToken(Fortran90Parser.NE, 0)
[docs]
def GT(self):
return self.getToken(Fortran90Parser.GT, 0)
[docs]
def GE(self):
return self.getToken(Fortran90Parser.GE, 0)
[docs]
def DIV(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.DIV)
else:
return self.getToken(Fortran90Parser.DIV, i)
[docs]
def SPOFF(self):
return self.getToken(Fortran90Parser.SPOFF, 0)
[docs]
def SPON(self):
return self.getToken(Fortran90Parser.SPON, 0)
[docs]
def LNOT(self):
return self.getToken(Fortran90Parser.LNOT, 0)
[docs]
def LAND(self):
return self.getToken(Fortran90Parser.LAND, 0)
[docs]
def LOR(self):
return self.getToken(Fortran90Parser.LOR, 0)
[docs]
def NEQV(self):
return self.getToken(Fortran90Parser.NEQV, 0)
[docs]
def EQV(self):
return self.getToken(Fortran90Parser.EQV, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_definedOperator
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDefinedOperator" ):
listener.enterDefinedOperator(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDefinedOperator" ):
listener.exitDefinedOperator(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDefinedOperator" ):
return visitor.visitDefinedOperator(self)
else:
return visitor.visitChildren(self)
[docs]
def definedOperator(self):
localctx = Fortran90Parser.DefinedOperatorContext(self, self._ctx, self.state)
self.enterRule(localctx, 200, self.RULE_definedOperator)
self._la = 0 # Token type
try:
self.state = 1490
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.DOP]:
self.enterOuterAlt(localctx, 1)
self.state = 1477
self.match(Fortran90Parser.DOP)
pass
elif token in [Fortran90Parser.POWER]:
self.enterOuterAlt(localctx, 2)
self.state = 1478
self.match(Fortran90Parser.POWER)
pass
elif token in [Fortran90Parser.STAR]:
self.enterOuterAlt(localctx, 3)
self.state = 1479
self.match(Fortran90Parser.STAR)
pass
elif token in [Fortran90Parser.MINUS, Fortran90Parser.PLUS]:
self.enterOuterAlt(localctx, 4)
self.state = 1480
_la = self._input.LA(1)
if not(_la==Fortran90Parser.MINUS or _la==Fortran90Parser.PLUS):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
pass
elif token in [Fortran90Parser.LT, Fortran90Parser.LE, Fortran90Parser.GT, Fortran90Parser.GE, Fortran90Parser.NE, Fortran90Parser.EQ]:
self.enterOuterAlt(localctx, 5)
self.state = 1481
_la = self._input.LA(1)
if not(((((_la - 143)) & ~0x3f) == 0 and ((1 << (_la - 143)) & ((1 << (Fortran90Parser.LT - 143)) | (1 << (Fortran90Parser.LE - 143)) | (1 << (Fortran90Parser.GT - 143)) | (1 << (Fortran90Parser.GE - 143)) | (1 << (Fortran90Parser.NE - 143)) | (1 << (Fortran90Parser.EQ - 143)))) != 0)):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
pass
elif token in [Fortran90Parser.DIV]:
self.enterOuterAlt(localctx, 6)
self.state = 1482
self.match(Fortran90Parser.DIV)
self.state = 1483
self.match(Fortran90Parser.SPOFF)
self.state = 1484
self.match(Fortran90Parser.DIV)
self.state = 1485
self.match(Fortran90Parser.SPON)
pass
elif token in [Fortran90Parser.LNOT]:
self.enterOuterAlt(localctx, 7)
self.state = 1486
self.match(Fortran90Parser.LNOT)
pass
elif token in [Fortran90Parser.LAND]:
self.enterOuterAlt(localctx, 8)
self.state = 1487
self.match(Fortran90Parser.LAND)
pass
elif token in [Fortran90Parser.LOR]:
self.enterOuterAlt(localctx, 9)
self.state = 1488
self.match(Fortran90Parser.LOR)
pass
elif token in [Fortran90Parser.EQV, Fortran90Parser.NEQV]:
self.enterOuterAlt(localctx, 10)
self.state = 1489
_la = self._input.LA(1)
if not(_la==Fortran90Parser.EQV or _la==Fortran90Parser.NEQV):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
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 InterfaceBlockBodyContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def interfaceBodyPartConstruct(self):
return self.getTypedRuleContext(Fortran90Parser.InterfaceBodyPartConstructContext,0)
[docs]
def interfaceBlockBody(self):
return self.getTypedRuleContext(Fortran90Parser.InterfaceBlockBodyContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_interfaceBlockBody
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterInterfaceBlockBody" ):
listener.enterInterfaceBlockBody(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitInterfaceBlockBody" ):
listener.exitInterfaceBlockBody(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitInterfaceBlockBody" ):
return visitor.visitInterfaceBlockBody(self)
else:
return visitor.visitChildren(self)
[docs]
def interfaceBlockBody(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = Fortran90Parser.InterfaceBlockBodyContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 202
self.enterRecursionRule(localctx, 202, self.RULE_interfaceBlockBody, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1493
self.interfaceBodyPartConstruct()
self._ctx.stop = self._input.LT(-1)
self.state = 1499
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,92,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = Fortran90Parser.InterfaceBlockBodyContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_interfaceBlockBody)
self.state = 1495
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 1496
self.interfaceBodyPartConstruct()
self.state = 1501
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,92,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class InterfaceBodyPartConstructContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def interfaceBody(self):
return self.getTypedRuleContext(Fortran90Parser.InterfaceBodyContext,0)
[docs]
def moduleProcedureStmt(self):
return self.getTypedRuleContext(Fortran90Parser.ModuleProcedureStmtContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_interfaceBodyPartConstruct
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterInterfaceBodyPartConstruct" ):
listener.enterInterfaceBodyPartConstruct(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitInterfaceBodyPartConstruct" ):
listener.exitInterfaceBodyPartConstruct(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitInterfaceBodyPartConstruct" ):
return visitor.visitInterfaceBodyPartConstruct(self)
else:
return visitor.visitChildren(self)
[docs]
def interfaceBodyPartConstruct(self):
localctx = Fortran90Parser.InterfaceBodyPartConstructContext(self, self._ctx, self.state)
self.enterRule(localctx, 204, self.RULE_interfaceBodyPartConstruct)
try:
self.state = 1504
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.RECURSIVE, Fortran90Parser.FUNCTION, Fortran90Parser.SUBROUTINE, Fortran90Parser.DOUBLEPRECISION, Fortran90Parser.REAL, Fortran90Parser.CHARACTER, Fortran90Parser.DOUBLE, Fortran90Parser.COMPLEX, Fortran90Parser.INTEGER, Fortran90Parser.LOGICAL, Fortran90Parser.TYPE]:
self.enterOuterAlt(localctx, 1)
self.state = 1502
self.interfaceBody()
pass
elif token in [Fortran90Parser.MODULE]:
self.enterOuterAlt(localctx, 2)
self.state = 1503
self.moduleProcedureStmt()
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 ModuleProcedureStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def MODULE(self):
return self.getToken(Fortran90Parser.MODULE, 0)
[docs]
def PROCEDURE(self):
return self.getToken(Fortran90Parser.PROCEDURE, 0)
[docs]
def procedureNameList(self):
return self.getTypedRuleContext(Fortran90Parser.ProcedureNameListContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_moduleProcedureStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterModuleProcedureStmt" ):
listener.enterModuleProcedureStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitModuleProcedureStmt" ):
listener.exitModuleProcedureStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitModuleProcedureStmt" ):
return visitor.visitModuleProcedureStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def moduleProcedureStmt(self):
localctx = Fortran90Parser.ModuleProcedureStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 206, self.RULE_moduleProcedureStmt)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1506
self.match(Fortran90Parser.MODULE)
self.state = 1507
self.match(Fortran90Parser.PROCEDURE)
self.state = 1508
self.procedureNameList()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ProcedureNameListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def procedureName(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.ProcedureNameContext)
else:
return self.getTypedRuleContext(Fortran90Parser.ProcedureNameContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_procedureNameList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterProcedureNameList" ):
listener.enterProcedureNameList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitProcedureNameList" ):
listener.exitProcedureNameList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitProcedureNameList" ):
return visitor.visitProcedureNameList(self)
else:
return visitor.visitChildren(self)
[docs]
def procedureNameList(self):
localctx = Fortran90Parser.ProcedureNameListContext(self, self._ctx, self.state)
self.enterRule(localctx, 208, self.RULE_procedureNameList)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1510
self.procedureName()
self.state = 1515
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,94,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 1511
self.match(Fortran90Parser.COMMA)
self.state = 1512
self.procedureName()
self.state = 1517
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,94,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 ProcedureNameContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ident(self):
return self.getTypedRuleContext(Fortran90Parser.IdentContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_procedureName
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterProcedureName" ):
listener.enterProcedureName(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitProcedureName" ):
listener.exitProcedureName(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitProcedureName" ):
return visitor.visitProcedureName(self)
else:
return visitor.visitChildren(self)
[docs]
def procedureName(self):
localctx = Fortran90Parser.ProcedureNameContext(self, self._ctx, self.state)
self.enterRule(localctx, 210, self.RULE_procedureName)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1518
self.ident()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class InterfaceBodyContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def functionPrefix(self):
return self.getTypedRuleContext(Fortran90Parser.FunctionPrefixContext,0)
[docs]
def NAME(self):
return self.getToken(Fortran90Parser.NAME, 0)
[docs]
def functionInterfaceRange(self):
return self.getTypedRuleContext(Fortran90Parser.FunctionInterfaceRangeContext,0)
[docs]
def SUBROUTINE(self):
return self.getToken(Fortran90Parser.SUBROUTINE, 0)
[docs]
def subroutineInterfaceRange(self):
return self.getTypedRuleContext(Fortran90Parser.SubroutineInterfaceRangeContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_interfaceBody
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterInterfaceBody" ):
listener.enterInterfaceBody(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitInterfaceBody" ):
listener.exitInterfaceBody(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitInterfaceBody" ):
return visitor.visitInterfaceBody(self)
else:
return visitor.visitChildren(self)
[docs]
def interfaceBody(self):
localctx = Fortran90Parser.InterfaceBodyContext(self, self._ctx, self.state)
self.enterRule(localctx, 212, self.RULE_interfaceBody)
try:
self.state = 1527
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.RECURSIVE, Fortran90Parser.FUNCTION, Fortran90Parser.DOUBLEPRECISION, Fortran90Parser.REAL, Fortran90Parser.CHARACTER, Fortran90Parser.DOUBLE, Fortran90Parser.COMPLEX, Fortran90Parser.INTEGER, Fortran90Parser.LOGICAL, Fortran90Parser.TYPE]:
self.enterOuterAlt(localctx, 1)
self.state = 1520
self.functionPrefix()
self.state = 1521
self.match(Fortran90Parser.NAME)
self.state = 1522
self.functionInterfaceRange()
pass
elif token in [Fortran90Parser.SUBROUTINE]:
self.enterOuterAlt(localctx, 2)
self.state = 1524
self.match(Fortran90Parser.SUBROUTINE)
self.state = 1525
self.match(Fortran90Parser.NAME)
self.state = 1526
self.subroutineInterfaceRange()
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 SubroutineInterfaceRangeContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def subroutineParList(self):
return self.getTypedRuleContext(Fortran90Parser.SubroutineParListContext,0)
[docs]
def endSubroutineStmt(self):
return self.getTypedRuleContext(Fortran90Parser.EndSubroutineStmtContext,0)
[docs]
def subprogramInterfaceBody(self):
return self.getTypedRuleContext(Fortran90Parser.SubprogramInterfaceBodyContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_subroutineInterfaceRange
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSubroutineInterfaceRange" ):
listener.enterSubroutineInterfaceRange(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSubroutineInterfaceRange" ):
listener.exitSubroutineInterfaceRange(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSubroutineInterfaceRange" ):
return visitor.visitSubroutineInterfaceRange(self)
else:
return visitor.visitChildren(self)
[docs]
def subroutineInterfaceRange(self):
localctx = Fortran90Parser.SubroutineInterfaceRangeContext(self, self._ctx, self.state)
self.enterRule(localctx, 214, self.RULE_subroutineInterfaceRange)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1529
self.subroutineParList()
self.state = 1531
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Fortran90Parser.ENTRY) | (1 << Fortran90Parser.DIMENSION) | (1 << Fortran90Parser.TARGET) | (1 << Fortran90Parser.ALLOCATABLE) | (1 << Fortran90Parser.OPTIONAL) | (1 << Fortran90Parser.NAMELIST) | (1 << Fortran90Parser.INTENT) | (1 << Fortran90Parser.USE) | (1 << Fortran90Parser.DOUBLEPRECISION) | (1 << Fortran90Parser.COMMON) | (1 << Fortran90Parser.REAL) | (1 << Fortran90Parser.EQUIVALENCE) | (1 << Fortran90Parser.POINTER) | (1 << Fortran90Parser.ACCESSSPEC) | (1 << Fortran90Parser.IMPLICIT) | (1 << Fortran90Parser.CHARACTER) | (1 << Fortran90Parser.PARAMETER) | (1 << Fortran90Parser.EXTERNAL) | (1 << Fortran90Parser.INTRINSIC) | (1 << Fortran90Parser.SAVE) | (1 << Fortran90Parser.DATA) | (1 << Fortran90Parser.INCLUDE))) != 0) or _la==Fortran90Parser.DOUBLE or ((((_la - 166)) & ~0x3f) == 0 and ((1 << (_la - 166)) & ((1 << (Fortran90Parser.COMPLEX - 166)) | (1 << (Fortran90Parser.INTEGER - 166)) | (1 << (Fortran90Parser.LOGICAL - 166)) | (1 << (Fortran90Parser.INTERFACE - 166)) | (1 << (Fortran90Parser.ICON - 166)) | (1 << (Fortran90Parser.TYPE - 166)))) != 0):
self.state = 1530
self.subprogramInterfaceBody(0)
self.state = 1533
self.endSubroutineStmt()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class EndSubroutineStmtContext(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(Fortran90Parser.END, 0)
[docs]
def SUBROUTINE(self):
return self.getToken(Fortran90Parser.SUBROUTINE, 0)
[docs]
def NAME(self):
return self.getToken(Fortran90Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_endSubroutineStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEndSubroutineStmt" ):
listener.enterEndSubroutineStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEndSubroutineStmt" ):
listener.exitEndSubroutineStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEndSubroutineStmt" ):
return visitor.visitEndSubroutineStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def endSubroutineStmt(self):
localctx = Fortran90Parser.EndSubroutineStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 216, self.RULE_endSubroutineStmt)
try:
self.state = 1541
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,98,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1535
self.match(Fortran90Parser.END)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1536
self.match(Fortran90Parser.END)
self.state = 1537
self.match(Fortran90Parser.SUBROUTINE)
self.state = 1539
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,97,self._ctx)
if la_ == 1:
self.state = 1538
self.match(Fortran90Parser.NAME)
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 RecursiveContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def RECURSIVE(self):
return self.getToken(Fortran90Parser.RECURSIVE, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_recursive
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterRecursive" ):
listener.enterRecursive(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitRecursive" ):
listener.exitRecursive(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitRecursive" ):
return visitor.visitRecursive(self)
else:
return visitor.visitChildren(self)
[docs]
def recursive(self):
localctx = Fortran90Parser.RecursiveContext(self, self._ctx, self.state)
self.enterRule(localctx, 218, self.RULE_recursive)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1543
self.match(Fortran90Parser.RECURSIVE)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class FunctionPrefixContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_functionPrefix
[docs]
def copyFrom(self, ctx:ParserRuleContext):
super().copyFrom(ctx)
[docs]
class FunctionPrefixRecContext(FunctionPrefixContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a Fortran90Parser.FunctionPrefixContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def FUNCTION(self):
return self.getToken(Fortran90Parser.FUNCTION, 0)
[docs]
def recursive(self):
return self.getTypedRuleContext(Fortran90Parser.RecursiveContext,0)
[docs]
def typeSpec(self):
return self.getTypedRuleContext(Fortran90Parser.TypeSpecContext,0)
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterFunctionPrefixRec" ):
listener.enterFunctionPrefixRec(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitFunctionPrefixRec" ):
listener.exitFunctionPrefixRec(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFunctionPrefixRec" ):
return visitor.visitFunctionPrefixRec(self)
else:
return visitor.visitChildren(self)
[docs]
class FunctionPrefixTypContext(FunctionPrefixContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a Fortran90Parser.FunctionPrefixContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def typeSpec(self):
return self.getTypedRuleContext(Fortran90Parser.TypeSpecContext,0)
[docs]
def RECURSIVE(self):
return self.getToken(Fortran90Parser.RECURSIVE, 0)
[docs]
def FUNCTION(self):
return self.getToken(Fortran90Parser.FUNCTION, 0)
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterFunctionPrefixTyp" ):
listener.enterFunctionPrefixTyp(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitFunctionPrefixTyp" ):
listener.exitFunctionPrefixTyp(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFunctionPrefixTyp" ):
return visitor.visitFunctionPrefixTyp(self)
else:
return visitor.visitChildren(self)
[docs]
def functionPrefix(self):
localctx = Fortran90Parser.FunctionPrefixContext(self, self._ctx, self.state)
self.enterRule(localctx, 220, self.RULE_functionPrefix)
self._la = 0 # Token type
try:
self.state = 1556
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,101,self._ctx)
if la_ == 1:
localctx = Fortran90Parser.FunctionPrefixRecContext(self, localctx)
self.enterOuterAlt(localctx, 1)
self.state = 1546
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.RECURSIVE:
self.state = 1545
self.recursive()
self.state = 1549
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Fortran90Parser.DOUBLEPRECISION) | (1 << Fortran90Parser.REAL) | (1 << Fortran90Parser.CHARACTER))) != 0) or _la==Fortran90Parser.DOUBLE or ((((_la - 166)) & ~0x3f) == 0 and ((1 << (_la - 166)) & ((1 << (Fortran90Parser.COMPLEX - 166)) | (1 << (Fortran90Parser.INTEGER - 166)) | (1 << (Fortran90Parser.LOGICAL - 166)) | (1 << (Fortran90Parser.TYPE - 166)))) != 0):
self.state = 1548
self.typeSpec()
self.state = 1551
self.match(Fortran90Parser.FUNCTION)
pass
elif la_ == 2:
localctx = Fortran90Parser.FunctionPrefixTypContext(self, localctx)
self.enterOuterAlt(localctx, 2)
self.state = 1552
self.typeSpec()
self.state = 1553
self.match(Fortran90Parser.RECURSIVE)
self.state = 1554
self.match(Fortran90Parser.FUNCTION)
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 FunctionInterfaceRangeContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def functionParList(self):
return self.getTypedRuleContext(Fortran90Parser.FunctionParListContext,0)
[docs]
def endFunctionStmt(self):
return self.getTypedRuleContext(Fortran90Parser.EndFunctionStmtContext,0)
[docs]
def subprogramInterfaceBody(self):
return self.getTypedRuleContext(Fortran90Parser.SubprogramInterfaceBodyContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_functionInterfaceRange
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterFunctionInterfaceRange" ):
listener.enterFunctionInterfaceRange(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitFunctionInterfaceRange" ):
listener.exitFunctionInterfaceRange(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFunctionInterfaceRange" ):
return visitor.visitFunctionInterfaceRange(self)
else:
return visitor.visitChildren(self)
[docs]
def functionInterfaceRange(self):
localctx = Fortran90Parser.FunctionInterfaceRangeContext(self, self._ctx, self.state)
self.enterRule(localctx, 222, self.RULE_functionInterfaceRange)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1558
self.functionParList()
self.state = 1560
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Fortran90Parser.ENTRY) | (1 << Fortran90Parser.DIMENSION) | (1 << Fortran90Parser.TARGET) | (1 << Fortran90Parser.ALLOCATABLE) | (1 << Fortran90Parser.OPTIONAL) | (1 << Fortran90Parser.NAMELIST) | (1 << Fortran90Parser.INTENT) | (1 << Fortran90Parser.USE) | (1 << Fortran90Parser.DOUBLEPRECISION) | (1 << Fortran90Parser.COMMON) | (1 << Fortran90Parser.REAL) | (1 << Fortran90Parser.EQUIVALENCE) | (1 << Fortran90Parser.POINTER) | (1 << Fortran90Parser.ACCESSSPEC) | (1 << Fortran90Parser.IMPLICIT) | (1 << Fortran90Parser.CHARACTER) | (1 << Fortran90Parser.PARAMETER) | (1 << Fortran90Parser.EXTERNAL) | (1 << Fortran90Parser.INTRINSIC) | (1 << Fortran90Parser.SAVE) | (1 << Fortran90Parser.DATA) | (1 << Fortran90Parser.INCLUDE))) != 0) or _la==Fortran90Parser.DOUBLE or ((((_la - 166)) & ~0x3f) == 0 and ((1 << (_la - 166)) & ((1 << (Fortran90Parser.COMPLEX - 166)) | (1 << (Fortran90Parser.INTEGER - 166)) | (1 << (Fortran90Parser.LOGICAL - 166)) | (1 << (Fortran90Parser.INTERFACE - 166)) | (1 << (Fortran90Parser.ICON - 166)) | (1 << (Fortran90Parser.TYPE - 166)))) != 0):
self.state = 1559
self.subprogramInterfaceBody(0)
self.state = 1562
self.endFunctionStmt()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class FunctionParListContext(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(Fortran90Parser.LPAREN, 0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def functionPars(self):
return self.getTypedRuleContext(Fortran90Parser.FunctionParsContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_functionParList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterFunctionParList" ):
listener.enterFunctionParList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitFunctionParList" ):
listener.exitFunctionParList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFunctionParList" ):
return visitor.visitFunctionParList(self)
else:
return visitor.visitChildren(self)
[docs]
def functionParList(self):
localctx = Fortran90Parser.FunctionParListContext(self, self._ctx, self.state)
self.enterRule(localctx, 224, self.RULE_functionParList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1564
self.match(Fortran90Parser.LPAREN)
self.state = 1566
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.NAME:
self.state = 1565
self.functionPars()
self.state = 1568
self.match(Fortran90Parser.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 FunctionParsContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def functionPar(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.FunctionParContext)
else:
return self.getTypedRuleContext(Fortran90Parser.FunctionParContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_functionPars
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterFunctionPars" ):
listener.enterFunctionPars(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitFunctionPars" ):
listener.exitFunctionPars(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFunctionPars" ):
return visitor.visitFunctionPars(self)
else:
return visitor.visitChildren(self)
[docs]
def functionPars(self):
localctx = Fortran90Parser.FunctionParsContext(self, self._ctx, self.state)
self.enterRule(localctx, 226, self.RULE_functionPars)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1570
self.functionPar()
self.state = 1575
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran90Parser.COMMA:
self.state = 1571
self.match(Fortran90Parser.COMMA)
self.state = 1572
self.functionPar()
self.state = 1577
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 FunctionParContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def dummyArgName(self):
return self.getTypedRuleContext(Fortran90Parser.DummyArgNameContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_functionPar
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterFunctionPar" ):
listener.enterFunctionPar(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitFunctionPar" ):
listener.exitFunctionPar(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFunctionPar" ):
return visitor.visitFunctionPar(self)
else:
return visitor.visitChildren(self)
[docs]
def functionPar(self):
localctx = Fortran90Parser.FunctionParContext(self, self._ctx, self.state)
self.enterRule(localctx, 228, self.RULE_functionPar)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1578
self.dummyArgName()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class SubprogramInterfaceBodyContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def specificationPartConstruct(self):
return self.getTypedRuleContext(Fortran90Parser.SpecificationPartConstructContext,0)
[docs]
def subprogramInterfaceBody(self):
return self.getTypedRuleContext(Fortran90Parser.SubprogramInterfaceBodyContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_subprogramInterfaceBody
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSubprogramInterfaceBody" ):
listener.enterSubprogramInterfaceBody(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSubprogramInterfaceBody" ):
listener.exitSubprogramInterfaceBody(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSubprogramInterfaceBody" ):
return visitor.visitSubprogramInterfaceBody(self)
else:
return visitor.visitChildren(self)
[docs]
def subprogramInterfaceBody(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = Fortran90Parser.SubprogramInterfaceBodyContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 230
self.enterRecursionRule(localctx, 230, self.RULE_subprogramInterfaceBody, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1581
self.specificationPartConstruct()
self._ctx.stop = self._input.LT(-1)
self.state = 1587
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,105,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = Fortran90Parser.SubprogramInterfaceBodyContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_subprogramInterfaceBody)
self.state = 1583
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 1584
self.specificationPartConstruct()
self.state = 1589
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,105,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class EndFunctionStmtContext(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(Fortran90Parser.END, 0)
[docs]
def FUNCTION(self):
return self.getToken(Fortran90Parser.FUNCTION, 0)
[docs]
def NAME(self):
return self.getToken(Fortran90Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_endFunctionStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEndFunctionStmt" ):
listener.enterEndFunctionStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEndFunctionStmt" ):
listener.exitEndFunctionStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEndFunctionStmt" ):
return visitor.visitEndFunctionStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def endFunctionStmt(self):
localctx = Fortran90Parser.EndFunctionStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 232, self.RULE_endFunctionStmt)
try:
self.state = 1596
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,107,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1590
self.match(Fortran90Parser.END)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1591
self.match(Fortran90Parser.END)
self.state = 1592
self.match(Fortran90Parser.FUNCTION)
self.state = 1594
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,106,self._ctx)
if la_ == 1:
self.state = 1593
self.match(Fortran90Parser.NAME)
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 DerivedTypeDefContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def derivedTypeStmt(self):
return self.getTypedRuleContext(Fortran90Parser.DerivedTypeStmtContext,0)
[docs]
def derivedTypeBody(self):
return self.getTypedRuleContext(Fortran90Parser.DerivedTypeBodyContext,0)
[docs]
def endTypeStmt(self):
return self.getTypedRuleContext(Fortran90Parser.EndTypeStmtContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_derivedTypeDef
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDerivedTypeDef" ):
listener.enterDerivedTypeDef(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDerivedTypeDef" ):
listener.exitDerivedTypeDef(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDerivedTypeDef" ):
return visitor.visitDerivedTypeDef(self)
else:
return visitor.visitChildren(self)
[docs]
def derivedTypeDef(self):
localctx = Fortran90Parser.DerivedTypeDefContext(self, self._ctx, self.state)
self.enterRule(localctx, 234, self.RULE_derivedTypeDef)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1598
self.derivedTypeStmt()
self.state = 1599
self.derivedTypeBody(0)
self.state = 1600
self.endTypeStmt()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class EndTypeStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ENDTYPE(self):
return self.getToken(Fortran90Parser.ENDTYPE, 0)
[docs]
def NAME(self):
return self.getToken(Fortran90Parser.NAME, 0)
[docs]
def END(self):
return self.getToken(Fortran90Parser.END, 0)
[docs]
def TYPE(self):
return self.getToken(Fortran90Parser.TYPE, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_endTypeStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEndTypeStmt" ):
listener.enterEndTypeStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEndTypeStmt" ):
listener.exitEndTypeStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEndTypeStmt" ):
return visitor.visitEndTypeStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def endTypeStmt(self):
localctx = Fortran90Parser.EndTypeStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 236, self.RULE_endTypeStmt)
try:
self.state = 1610
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,108,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1602
self.match(Fortran90Parser.ENDTYPE)
self.state = 1603
self.match(Fortran90Parser.NAME)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1604
self.match(Fortran90Parser.ENDTYPE)
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 1605
self.match(Fortran90Parser.END)
self.state = 1606
self.match(Fortran90Parser.TYPE)
self.state = 1607
self.match(Fortran90Parser.NAME)
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 1608
self.match(Fortran90Parser.END)
self.state = 1609
self.match(Fortran90Parser.TYPE)
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 DerivedTypeStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def TYPE(self):
return self.getToken(Fortran90Parser.TYPE, 0)
[docs]
def NAME(self):
return self.getToken(Fortran90Parser.NAME, 0)
[docs]
def DOUBLECOLON(self):
return self.getToken(Fortran90Parser.DOUBLECOLON, 0)
[docs]
def COMMA(self):
return self.getToken(Fortran90Parser.COMMA, 0)
[docs]
def ACCESSSPEC(self):
return self.getToken(Fortran90Parser.ACCESSSPEC, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_derivedTypeStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDerivedTypeStmt" ):
listener.enterDerivedTypeStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDerivedTypeStmt" ):
listener.exitDerivedTypeStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDerivedTypeStmt" ):
return visitor.visitDerivedTypeStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def derivedTypeStmt(self):
localctx = Fortran90Parser.DerivedTypeStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 238, self.RULE_derivedTypeStmt)
try:
self.state = 1622
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,109,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1612
self.match(Fortran90Parser.TYPE)
self.state = 1613
self.match(Fortran90Parser.NAME)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1614
self.match(Fortran90Parser.TYPE)
self.state = 1615
self.match(Fortran90Parser.DOUBLECOLON)
self.state = 1616
self.match(Fortran90Parser.NAME)
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 1617
self.match(Fortran90Parser.TYPE)
self.state = 1618
self.match(Fortran90Parser.COMMA)
self.state = 1619
self.match(Fortran90Parser.ACCESSSPEC)
self.state = 1620
self.match(Fortran90Parser.DOUBLECOLON)
self.state = 1621
self.match(Fortran90Parser.NAME)
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 DerivedTypeBodyContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def derivedTypeBodyConstruct(self):
return self.getTypedRuleContext(Fortran90Parser.DerivedTypeBodyConstructContext,0)
[docs]
def derivedTypeBody(self):
return self.getTypedRuleContext(Fortran90Parser.DerivedTypeBodyContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_derivedTypeBody
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDerivedTypeBody" ):
listener.enterDerivedTypeBody(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDerivedTypeBody" ):
listener.exitDerivedTypeBody(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDerivedTypeBody" ):
return visitor.visitDerivedTypeBody(self)
else:
return visitor.visitChildren(self)
[docs]
def derivedTypeBody(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = Fortran90Parser.DerivedTypeBodyContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 240
self.enterRecursionRule(localctx, 240, self.RULE_derivedTypeBody, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1625
self.derivedTypeBodyConstruct()
self._ctx.stop = self._input.LT(-1)
self.state = 1631
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,110,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = Fortran90Parser.DerivedTypeBodyContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_derivedTypeBody)
self.state = 1627
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 1628
self.derivedTypeBodyConstruct()
self.state = 1633
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,110,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class DerivedTypeBodyConstructContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def privateSequenceStmt(self):
return self.getTypedRuleContext(Fortran90Parser.PrivateSequenceStmtContext,0)
[docs]
def componentDefStmt(self):
return self.getTypedRuleContext(Fortran90Parser.ComponentDefStmtContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_derivedTypeBodyConstruct
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDerivedTypeBodyConstruct" ):
listener.enterDerivedTypeBodyConstruct(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDerivedTypeBodyConstruct" ):
listener.exitDerivedTypeBodyConstruct(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDerivedTypeBodyConstruct" ):
return visitor.visitDerivedTypeBodyConstruct(self)
else:
return visitor.visitChildren(self)
[docs]
def derivedTypeBodyConstruct(self):
localctx = Fortran90Parser.DerivedTypeBodyConstructContext(self, self._ctx, self.state)
self.enterRule(localctx, 242, self.RULE_derivedTypeBodyConstruct)
try:
self.state = 1636
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.PRIVATE, Fortran90Parser.SEQUENCE]:
self.enterOuterAlt(localctx, 1)
self.state = 1634
self.privateSequenceStmt()
pass
elif token in [Fortran90Parser.DOUBLEPRECISION, Fortran90Parser.REAL, Fortran90Parser.CHARACTER, Fortran90Parser.DOUBLE, Fortran90Parser.COMPLEX, Fortran90Parser.INTEGER, Fortran90Parser.LOGICAL, Fortran90Parser.TYPE]:
self.enterOuterAlt(localctx, 2)
self.state = 1635
self.componentDefStmt()
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 PrivateSequenceStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def PRIVATE(self):
return self.getToken(Fortran90Parser.PRIVATE, 0)
[docs]
def SEQUENCE(self):
return self.getToken(Fortran90Parser.SEQUENCE, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_privateSequenceStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPrivateSequenceStmt" ):
listener.enterPrivateSequenceStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPrivateSequenceStmt" ):
listener.exitPrivateSequenceStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPrivateSequenceStmt" ):
return visitor.visitPrivateSequenceStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def privateSequenceStmt(self):
localctx = Fortran90Parser.PrivateSequenceStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 244, self.RULE_privateSequenceStmt)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1638
_la = self._input.LA(1)
if not(_la==Fortran90Parser.PRIVATE or _la==Fortran90Parser.SEQUENCE):
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 ComponentDefStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def typeSpec(self):
return self.getTypedRuleContext(Fortran90Parser.TypeSpecContext,0)
[docs]
def COMMA(self):
return self.getToken(Fortran90Parser.COMMA, 0)
[docs]
def componentAttrSpecList(self):
return self.getTypedRuleContext(Fortran90Parser.ComponentAttrSpecListContext,0)
[docs]
def DOUBLECOLON(self):
return self.getToken(Fortran90Parser.DOUBLECOLON, 0)
[docs]
def componentDeclList(self):
return self.getTypedRuleContext(Fortran90Parser.ComponentDeclListContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_componentDefStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterComponentDefStmt" ):
listener.enterComponentDefStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitComponentDefStmt" ):
listener.exitComponentDefStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitComponentDefStmt" ):
return visitor.visitComponentDefStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def componentDefStmt(self):
localctx = Fortran90Parser.ComponentDefStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 246, self.RULE_componentDefStmt)
try:
self.state = 1653
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,112,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1640
self.typeSpec()
self.state = 1641
self.match(Fortran90Parser.COMMA)
self.state = 1642
self.componentAttrSpecList()
self.state = 1643
self.match(Fortran90Parser.DOUBLECOLON)
self.state = 1644
self.componentDeclList()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1646
self.typeSpec()
self.state = 1647
self.match(Fortran90Parser.DOUBLECOLON)
self.state = 1648
self.componentDeclList()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 1650
self.typeSpec()
self.state = 1651
self.componentDeclList()
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 ComponentDeclListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def componentDecl(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.ComponentDeclContext)
else:
return self.getTypedRuleContext(Fortran90Parser.ComponentDeclContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_componentDeclList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterComponentDeclList" ):
listener.enterComponentDeclList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitComponentDeclList" ):
listener.exitComponentDeclList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitComponentDeclList" ):
return visitor.visitComponentDeclList(self)
else:
return visitor.visitChildren(self)
[docs]
def componentDeclList(self):
localctx = Fortran90Parser.ComponentDeclListContext(self, self._ctx, self.state)
self.enterRule(localctx, 248, self.RULE_componentDeclList)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1655
self.componentDecl()
self.state = 1660
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,113,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 1656
self.match(Fortran90Parser.COMMA)
self.state = 1657
self.componentDecl()
self.state = 1662
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,113,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 ComponentDeclContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def componentName(self):
return self.getTypedRuleContext(Fortran90Parser.ComponentNameContext,0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def componentArraySpec(self):
return self.getTypedRuleContext(Fortran90Parser.ComponentArraySpecContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def STAR(self):
return self.getToken(Fortran90Parser.STAR, 0)
[docs]
def charLength(self):
return self.getTypedRuleContext(Fortran90Parser.CharLengthContext,0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran90Parser.ASSIGN, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_componentDecl
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterComponentDecl" ):
listener.enterComponentDecl(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitComponentDecl" ):
listener.exitComponentDecl(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitComponentDecl" ):
return visitor.visitComponentDecl(self)
else:
return visitor.visitChildren(self)
[docs]
def componentDecl(self):
localctx = Fortran90Parser.ComponentDeclContext(self, self._ctx, self.state)
self.enterRule(localctx, 250, self.RULE_componentDecl)
try:
self.state = 1706
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,114,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1663
self.componentName()
self.state = 1664
self.match(Fortran90Parser.LPAREN)
self.state = 1665
self.componentArraySpec()
self.state = 1666
self.match(Fortran90Parser.RPAREN)
self.state = 1667
self.match(Fortran90Parser.STAR)
self.state = 1668
self.charLength()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1670
self.componentName()
self.state = 1671
self.match(Fortran90Parser.LPAREN)
self.state = 1672
self.componentArraySpec()
self.state = 1673
self.match(Fortran90Parser.RPAREN)
self.state = 1674
self.match(Fortran90Parser.ASSIGN)
self.state = 1675
self.expression(0)
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 1677
self.componentName()
self.state = 1678
self.match(Fortran90Parser.LPAREN)
self.state = 1679
self.componentArraySpec()
self.state = 1680
self.match(Fortran90Parser.RPAREN)
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 1682
self.componentName()
self.state = 1683
self.match(Fortran90Parser.STAR)
self.state = 1684
self.charLength()
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 1686
self.componentName()
self.state = 1687
self.match(Fortran90Parser.ASSIGN)
self.state = 1688
self.expression(0)
pass
elif la_ == 6:
self.enterOuterAlt(localctx, 6)
self.state = 1690
self.componentName()
self.state = 1691
self.match(Fortran90Parser.STAR)
self.state = 1692
self.charLength()
self.state = 1693
self.match(Fortran90Parser.ASSIGN)
self.state = 1694
self.expression(0)
pass
elif la_ == 7:
self.enterOuterAlt(localctx, 7)
self.state = 1696
self.componentName()
self.state = 1697
self.match(Fortran90Parser.STAR)
self.state = 1698
self.charLength()
self.state = 1699
self.match(Fortran90Parser.LPAREN)
self.state = 1700
self.componentArraySpec()
self.state = 1701
self.match(Fortran90Parser.RPAREN)
self.state = 1702
self.match(Fortran90Parser.ASSIGN)
self.state = 1703
self.expression(0)
pass
elif la_ == 8:
self.enterOuterAlt(localctx, 8)
self.state = 1705
self.componentName()
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 ComponentNameContext(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(Fortran90Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_componentName
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterComponentName" ):
listener.enterComponentName(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitComponentName" ):
listener.exitComponentName(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitComponentName" ):
return visitor.visitComponentName(self)
else:
return visitor.visitChildren(self)
[docs]
def componentName(self):
localctx = Fortran90Parser.ComponentNameContext(self, self._ctx, self.state)
self.enterRule(localctx, 252, self.RULE_componentName)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1708
self.match(Fortran90Parser.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 ComponentAttrSpecListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def componentAttrSpec(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.ComponentAttrSpecContext)
else:
return self.getTypedRuleContext(Fortran90Parser.ComponentAttrSpecContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_componentAttrSpecList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterComponentAttrSpecList" ):
listener.enterComponentAttrSpecList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitComponentAttrSpecList" ):
listener.exitComponentAttrSpecList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitComponentAttrSpecList" ):
return visitor.visitComponentAttrSpecList(self)
else:
return visitor.visitChildren(self)
[docs]
def componentAttrSpecList(self):
localctx = Fortran90Parser.ComponentAttrSpecListContext(self, self._ctx, self.state)
self.enterRule(localctx, 254, self.RULE_componentAttrSpecList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1710
self.componentAttrSpec()
self.state = 1715
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran90Parser.COMMA:
self.state = 1711
self.match(Fortran90Parser.COMMA)
self.state = 1712
self.componentAttrSpec()
self.state = 1717
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 ComponentAttrSpecContext(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(Fortran90Parser.POINTER, 0)
[docs]
def DIMENSION(self):
return self.getToken(Fortran90Parser.DIMENSION, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def componentArraySpec(self):
return self.getTypedRuleContext(Fortran90Parser.ComponentArraySpecContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_componentAttrSpec
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterComponentAttrSpec" ):
listener.enterComponentAttrSpec(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitComponentAttrSpec" ):
listener.exitComponentAttrSpec(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitComponentAttrSpec" ):
return visitor.visitComponentAttrSpec(self)
else:
return visitor.visitChildren(self)
[docs]
def componentAttrSpec(self):
localctx = Fortran90Parser.ComponentAttrSpecContext(self, self._ctx, self.state)
self.enterRule(localctx, 256, self.RULE_componentAttrSpec)
try:
self.state = 1724
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.POINTER]:
self.enterOuterAlt(localctx, 1)
self.state = 1718
self.match(Fortran90Parser.POINTER)
pass
elif token in [Fortran90Parser.DIMENSION]:
self.enterOuterAlt(localctx, 2)
self.state = 1719
self.match(Fortran90Parser.DIMENSION)
self.state = 1720
self.match(Fortran90Parser.LPAREN)
self.state = 1721
self.componentArraySpec()
self.state = 1722
self.match(Fortran90Parser.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 ComponentArraySpecContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def explicitShapeSpecList(self):
return self.getTypedRuleContext(Fortran90Parser.ExplicitShapeSpecListContext,0)
[docs]
def deferredShapeSpecList(self):
return self.getTypedRuleContext(Fortran90Parser.DeferredShapeSpecListContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_componentArraySpec
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterComponentArraySpec" ):
listener.enterComponentArraySpec(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitComponentArraySpec" ):
listener.exitComponentArraySpec(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitComponentArraySpec" ):
return visitor.visitComponentArraySpec(self)
else:
return visitor.visitChildren(self)
[docs]
def componentArraySpec(self):
localctx = Fortran90Parser.ComponentArraySpecContext(self, self._ctx, self.state)
self.enterRule(localctx, 258, self.RULE_componentArraySpec)
try:
self.state = 1728
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.DOP, Fortran90Parser.REAL, Fortran90Parser.SIZE, Fortran90Parser.LPAREN, Fortran90Parser.MINUS, Fortran90Parser.PLUS, Fortran90Parser.LNOT, Fortran90Parser.TRUE, Fortran90Parser.FALSE, Fortran90Parser.OBRACKETSLASH, Fortran90Parser.SCON, Fortran90Parser.RDCON, Fortran90Parser.ICON, Fortran90Parser.NAME]:
self.enterOuterAlt(localctx, 1)
self.state = 1726
self.explicitShapeSpecList()
pass
elif token in [Fortran90Parser.COLON]:
self.enterOuterAlt(localctx, 2)
self.state = 1727
self.deferredShapeSpecList()
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 ExplicitShapeSpecListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def explicitShapeSpec(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.ExplicitShapeSpecContext)
else:
return self.getTypedRuleContext(Fortran90Parser.ExplicitShapeSpecContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_explicitShapeSpecList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterExplicitShapeSpecList" ):
listener.enterExplicitShapeSpecList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitExplicitShapeSpecList" ):
listener.exitExplicitShapeSpecList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitExplicitShapeSpecList" ):
return visitor.visitExplicitShapeSpecList(self)
else:
return visitor.visitChildren(self)
[docs]
def explicitShapeSpecList(self):
localctx = Fortran90Parser.ExplicitShapeSpecListContext(self, self._ctx, self.state)
self.enterRule(localctx, 260, self.RULE_explicitShapeSpecList)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1730
self.explicitShapeSpec()
self.state = 1735
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,118,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 1731
self.match(Fortran90Parser.COMMA)
self.state = 1732
self.explicitShapeSpec()
self.state = 1737
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,118,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 ExplicitShapeSpecContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def lowerBound(self):
return self.getTypedRuleContext(Fortran90Parser.LowerBoundContext,0)
[docs]
def COLON(self):
return self.getToken(Fortran90Parser.COLON, 0)
[docs]
def upperBound(self):
return self.getTypedRuleContext(Fortran90Parser.UpperBoundContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_explicitShapeSpec
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterExplicitShapeSpec" ):
listener.enterExplicitShapeSpec(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitExplicitShapeSpec" ):
listener.exitExplicitShapeSpec(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitExplicitShapeSpec" ):
return visitor.visitExplicitShapeSpec(self)
else:
return visitor.visitChildren(self)
[docs]
def explicitShapeSpec(self):
localctx = Fortran90Parser.ExplicitShapeSpecContext(self, self._ctx, self.state)
self.enterRule(localctx, 262, self.RULE_explicitShapeSpec)
try:
self.state = 1743
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,119,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1738
self.lowerBound()
self.state = 1739
self.match(Fortran90Parser.COLON)
self.state = 1740
self.upperBound()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1742
self.upperBound()
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 LowerBoundContext(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(Fortran90Parser.ExpressionContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_lowerBound
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLowerBound" ):
listener.enterLowerBound(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLowerBound" ):
listener.exitLowerBound(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLowerBound" ):
return visitor.visitLowerBound(self)
else:
return visitor.visitChildren(self)
[docs]
def lowerBound(self):
localctx = Fortran90Parser.LowerBoundContext(self, self._ctx, self.state)
self.enterRule(localctx, 264, self.RULE_lowerBound)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1745
self.expression(0)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class UpperBoundContext(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(Fortran90Parser.ExpressionContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_upperBound
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterUpperBound" ):
listener.enterUpperBound(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitUpperBound" ):
listener.exitUpperBound(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitUpperBound" ):
return visitor.visitUpperBound(self)
else:
return visitor.visitChildren(self)
[docs]
def upperBound(self):
localctx = Fortran90Parser.UpperBoundContext(self, self._ctx, self.state)
self.enterRule(localctx, 266, self.RULE_upperBound)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1747
self.expression(0)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class DeferredShapeSpecListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def deferredShapeSpec(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.DeferredShapeSpecContext)
else:
return self.getTypedRuleContext(Fortran90Parser.DeferredShapeSpecContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_deferredShapeSpecList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDeferredShapeSpecList" ):
listener.enterDeferredShapeSpecList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDeferredShapeSpecList" ):
listener.exitDeferredShapeSpecList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDeferredShapeSpecList" ):
return visitor.visitDeferredShapeSpecList(self)
else:
return visitor.visitChildren(self)
[docs]
def deferredShapeSpecList(self):
localctx = Fortran90Parser.DeferredShapeSpecListContext(self, self._ctx, self.state)
self.enterRule(localctx, 268, self.RULE_deferredShapeSpecList)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1749
self.deferredShapeSpec()
self.state = 1754
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,120,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 1750
self.match(Fortran90Parser.COMMA)
self.state = 1751
self.deferredShapeSpec()
self.state = 1756
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,120,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 DeferredShapeSpecContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def COLON(self):
return self.getToken(Fortran90Parser.COLON, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_deferredShapeSpec
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDeferredShapeSpec" ):
listener.enterDeferredShapeSpec(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDeferredShapeSpec" ):
listener.exitDeferredShapeSpec(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDeferredShapeSpec" ):
return visitor.visitDeferredShapeSpec(self)
else:
return visitor.visitChildren(self)
[docs]
def deferredShapeSpec(self):
localctx = Fortran90Parser.DeferredShapeSpecContext(self, self._ctx, self.state)
self.enterRule(localctx, 270, self.RULE_deferredShapeSpec)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1757
self.match(Fortran90Parser.COLON)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class TypeSpecContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def INTEGER(self):
return self.getToken(Fortran90Parser.INTEGER, 0)
[docs]
def REAL(self):
return self.getToken(Fortran90Parser.REAL, 0)
[docs]
def DOUBLEPRECISION(self):
return self.getToken(Fortran90Parser.DOUBLEPRECISION, 0)
[docs]
def COMPLEX(self):
return self.getToken(Fortran90Parser.COMPLEX, 0)
[docs]
def LOGICAL(self):
return self.getToken(Fortran90Parser.LOGICAL, 0)
[docs]
def CHARACTER(self):
return self.getToken(Fortran90Parser.CHARACTER, 0)
[docs]
def lengthSelector(self):
return self.getTypedRuleContext(Fortran90Parser.LengthSelectorContext,0)
[docs]
def kindSelector(self):
return self.getTypedRuleContext(Fortran90Parser.KindSelectorContext,0)
[docs]
def DOUBLE(self):
return self.getToken(Fortran90Parser.DOUBLE, 0)
[docs]
def PRECISION(self):
return self.getToken(Fortran90Parser.PRECISION, 0)
[docs]
def charSelector(self):
return self.getTypedRuleContext(Fortran90Parser.CharSelectorContext,0)
[docs]
def TYPE(self):
return self.getToken(Fortran90Parser.TYPE, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def typeName(self):
return self.getTypedRuleContext(Fortran90Parser.TypeNameContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_typeSpec
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTypeSpec" ):
listener.enterTypeSpec(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTypeSpec" ):
listener.exitTypeSpec(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTypeSpec" ):
return visitor.visitTypeSpec(self)
else:
return visitor.visitChildren(self)
[docs]
def typeSpec(self):
localctx = Fortran90Parser.TypeSpecContext(self, self._ctx, self.state)
self.enterRule(localctx, 272, self.RULE_typeSpec)
try:
self.state = 1784
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,121,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1759
self.match(Fortran90Parser.INTEGER)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1760
self.match(Fortran90Parser.REAL)
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 1761
self.match(Fortran90Parser.DOUBLEPRECISION)
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 1762
self.match(Fortran90Parser.COMPLEX)
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 1763
self.match(Fortran90Parser.LOGICAL)
pass
elif la_ == 6:
self.enterOuterAlt(localctx, 6)
self.state = 1764
self.match(Fortran90Parser.CHARACTER)
pass
elif la_ == 7:
self.enterOuterAlt(localctx, 7)
self.state = 1765
self.match(Fortran90Parser.CHARACTER)
self.state = 1766
self.lengthSelector()
pass
elif la_ == 8:
self.enterOuterAlt(localctx, 8)
self.state = 1767
self.match(Fortran90Parser.INTEGER)
self.state = 1768
self.kindSelector()
pass
elif la_ == 9:
self.enterOuterAlt(localctx, 9)
self.state = 1769
self.match(Fortran90Parser.REAL)
self.state = 1770
self.kindSelector()
pass
elif la_ == 10:
self.enterOuterAlt(localctx, 10)
self.state = 1771
self.match(Fortran90Parser.DOUBLE)
self.state = 1772
self.match(Fortran90Parser.PRECISION)
pass
elif la_ == 11:
self.enterOuterAlt(localctx, 11)
self.state = 1773
self.match(Fortran90Parser.COMPLEX)
self.state = 1774
self.kindSelector()
pass
elif la_ == 12:
self.enterOuterAlt(localctx, 12)
self.state = 1775
self.match(Fortran90Parser.CHARACTER)
self.state = 1776
self.charSelector()
pass
elif la_ == 13:
self.enterOuterAlt(localctx, 13)
self.state = 1777
self.match(Fortran90Parser.LOGICAL)
self.state = 1778
self.kindSelector()
pass
elif la_ == 14:
self.enterOuterAlt(localctx, 14)
self.state = 1779
self.match(Fortran90Parser.TYPE)
self.state = 1780
self.match(Fortran90Parser.LPAREN)
self.state = 1781
self.typeName()
self.state = 1782
self.match(Fortran90Parser.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 KindSelectorContext(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(Fortran90Parser.LPAREN, 0)
[docs]
def KIND(self):
return self.getToken(Fortran90Parser.KIND, 0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran90Parser.ASSIGN, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_kindSelector
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterKindSelector" ):
listener.enterKindSelector(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitKindSelector" ):
listener.exitKindSelector(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitKindSelector" ):
return visitor.visitKindSelector(self)
else:
return visitor.visitChildren(self)
[docs]
def kindSelector(self):
localctx = Fortran90Parser.KindSelectorContext(self, self._ctx, self.state)
self.enterRule(localctx, 274, self.RULE_kindSelector)
try:
self.state = 1796
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,122,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1786
self.match(Fortran90Parser.LPAREN)
self.state = 1787
self.match(Fortran90Parser.KIND)
self.state = 1788
self.match(Fortran90Parser.ASSIGN)
self.state = 1789
self.expression(0)
self.state = 1790
self.match(Fortran90Parser.RPAREN)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1792
self.match(Fortran90Parser.LPAREN)
self.state = 1793
self.expression(0)
self.state = 1794
self.match(Fortran90Parser.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 TypeNameContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ident(self):
return self.getTypedRuleContext(Fortran90Parser.IdentContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.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 = Fortran90Parser.TypeNameContext(self, self._ctx, self.state)
self.enterRule(localctx, 276, self.RULE_typeName)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1798
self.ident()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class CharSelectorContext(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(Fortran90Parser.LPAREN, 0)
[docs]
def LEN(self):
return self.getToken(Fortran90Parser.LEN, 0)
[docs]
def ASSIGN(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.ASSIGN)
else:
return self.getToken(Fortran90Parser.ASSIGN, i)
[docs]
def typeParamValue(self):
return self.getTypedRuleContext(Fortran90Parser.TypeParamValueContext,0)
[docs]
def COMMA(self):
return self.getToken(Fortran90Parser.COMMA, 0)
[docs]
def KIND(self):
return self.getToken(Fortran90Parser.KIND, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_charSelector
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCharSelector" ):
listener.enterCharSelector(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCharSelector" ):
listener.exitCharSelector(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCharSelector" ):
return visitor.visitCharSelector(self)
else:
return visitor.visitChildren(self)
[docs]
def charSelector(self):
localctx = Fortran90Parser.CharSelectorContext(self, self._ctx, self.state)
self.enterRule(localctx, 278, self.RULE_charSelector)
try:
self.state = 1834
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,123,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1800
self.match(Fortran90Parser.LPAREN)
self.state = 1801
self.match(Fortran90Parser.LEN)
self.state = 1802
self.match(Fortran90Parser.ASSIGN)
self.state = 1803
self.typeParamValue()
self.state = 1804
self.match(Fortran90Parser.COMMA)
self.state = 1805
self.match(Fortran90Parser.KIND)
self.state = 1806
self.match(Fortran90Parser.ASSIGN)
self.state = 1807
self.expression(0)
self.state = 1808
self.match(Fortran90Parser.RPAREN)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1810
self.match(Fortran90Parser.LPAREN)
self.state = 1811
self.match(Fortran90Parser.LEN)
self.state = 1812
self.match(Fortran90Parser.ASSIGN)
self.state = 1813
self.typeParamValue()
self.state = 1814
self.match(Fortran90Parser.COMMA)
self.state = 1815
self.expression(0)
self.state = 1816
self.match(Fortran90Parser.RPAREN)
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 1818
self.match(Fortran90Parser.LPAREN)
self.state = 1819
self.match(Fortran90Parser.LEN)
self.state = 1820
self.match(Fortran90Parser.ASSIGN)
self.state = 1821
self.typeParamValue()
self.state = 1822
self.match(Fortran90Parser.RPAREN)
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 1824
self.match(Fortran90Parser.LPAREN)
self.state = 1825
self.match(Fortran90Parser.KIND)
self.state = 1826
self.match(Fortran90Parser.ASSIGN)
self.state = 1827
self.expression(0)
self.state = 1828
self.match(Fortran90Parser.RPAREN)
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 1830
self.match(Fortran90Parser.LPAREN)
self.state = 1831
self.expression(0)
self.state = 1832
self.match(Fortran90Parser.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 LengthSelectorContext(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(Fortran90Parser.STAR, 0)
[docs]
def charLength(self):
return self.getTypedRuleContext(Fortran90Parser.CharLengthContext,0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def typeParamValue(self):
return self.getTypedRuleContext(Fortran90Parser.TypeParamValueContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_lengthSelector
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLengthSelector" ):
listener.enterLengthSelector(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLengthSelector" ):
listener.exitLengthSelector(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLengthSelector" ):
return visitor.visitLengthSelector(self)
else:
return visitor.visitChildren(self)
[docs]
def lengthSelector(self):
localctx = Fortran90Parser.LengthSelectorContext(self, self._ctx, self.state)
self.enterRule(localctx, 280, self.RULE_lengthSelector)
try:
self.state = 1842
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.STAR]:
self.enterOuterAlt(localctx, 1)
self.state = 1836
self.match(Fortran90Parser.STAR)
self.state = 1837
self.charLength()
pass
elif token in [Fortran90Parser.LPAREN]:
self.enterOuterAlt(localctx, 2)
self.state = 1838
self.match(Fortran90Parser.LPAREN)
self.state = 1839
self.typeParamValue()
self.state = 1840
self.match(Fortran90Parser.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 CharLengthContext(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(Fortran90Parser.LPAREN, 0)
[docs]
def typeParamValue(self):
return self.getTypedRuleContext(Fortran90Parser.TypeParamValueContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def constant(self):
return self.getTypedRuleContext(Fortran90Parser.ConstantContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_charLength
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCharLength" ):
listener.enterCharLength(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCharLength" ):
listener.exitCharLength(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCharLength" ):
return visitor.visitCharLength(self)
else:
return visitor.visitChildren(self)
[docs]
def charLength(self):
localctx = Fortran90Parser.CharLengthContext(self, self._ctx, self.state)
self.enterRule(localctx, 282, self.RULE_charLength)
try:
self.state = 1849
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,125,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1844
self.match(Fortran90Parser.LPAREN)
self.state = 1845
self.typeParamValue()
self.state = 1846
self.match(Fortran90Parser.RPAREN)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1848
self.constant()
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 ConstantContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def namedConstantUse(self):
return self.getTypedRuleContext(Fortran90Parser.NamedConstantUseContext,0)
[docs]
def unsignedArithmeticConstant(self):
return self.getTypedRuleContext(Fortran90Parser.UnsignedArithmeticConstantContext,0)
[docs]
def PLUS(self):
return self.getToken(Fortran90Parser.PLUS, 0)
[docs]
def MINUS(self):
return self.getToken(Fortran90Parser.MINUS, 0)
[docs]
def SCON(self):
return self.getToken(Fortran90Parser.SCON, 0)
[docs]
def HOLLERITH(self):
return self.getToken(Fortran90Parser.HOLLERITH, 0)
[docs]
def logicalConstant(self):
return self.getTypedRuleContext(Fortran90Parser.LogicalConstantContext,0)
[docs]
def ICON(self):
return self.getToken(Fortran90Parser.ICON, 0)
[docs]
def UNDERSCORE(self):
return self.getToken(Fortran90Parser.UNDERSCORE, 0)
[docs]
def structureConstructor(self):
return self.getTypedRuleContext(Fortran90Parser.StructureConstructorContext,0)
[docs]
def bozLiteralConstant(self):
return self.getTypedRuleContext(Fortran90Parser.BozLiteralConstantContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.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 = Fortran90Parser.ConstantContext(self, self._ctx, self.state)
self.enterRule(localctx, 284, self.RULE_constant)
self._la = 0 # Token type
try:
self.state = 1868
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,127,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1851
self.namedConstantUse()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1853
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.MINUS or _la==Fortran90Parser.PLUS:
self.state = 1852
_la = self._input.LA(1)
if not(_la==Fortran90Parser.MINUS or _la==Fortran90Parser.PLUS):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 1855
self.unsignedArithmeticConstant()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 1856
self.match(Fortran90Parser.SCON)
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 1857
self.match(Fortran90Parser.HOLLERITH)
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 1858
self.logicalConstant()
pass
elif la_ == 6:
self.enterOuterAlt(localctx, 6)
self.state = 1859
self.match(Fortran90Parser.ICON)
self.state = 1860
self.match(Fortran90Parser.UNDERSCORE)
self.state = 1861
self.match(Fortran90Parser.SCON)
pass
elif la_ == 7:
self.enterOuterAlt(localctx, 7)
self.state = 1862
self.namedConstantUse()
self.state = 1863
self.match(Fortran90Parser.UNDERSCORE)
self.state = 1864
self.match(Fortran90Parser.SCON)
pass
elif la_ == 8:
self.enterOuterAlt(localctx, 8)
self.state = 1866
self.structureConstructor()
pass
elif la_ == 9:
self.enterOuterAlt(localctx, 9)
self.state = 1867
self.bozLiteralConstant()
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 BozLiteralConstantContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def BCON(self):
return self.getToken(Fortran90Parser.BCON, 0)
[docs]
def OCON(self):
return self.getToken(Fortran90Parser.OCON, 0)
[docs]
def ZCON(self):
return self.getToken(Fortran90Parser.ZCON, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_bozLiteralConstant
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterBozLiteralConstant" ):
listener.enterBozLiteralConstant(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitBozLiteralConstant" ):
listener.exitBozLiteralConstant(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitBozLiteralConstant" ):
return visitor.visitBozLiteralConstant(self)
else:
return visitor.visitChildren(self)
[docs]
def bozLiteralConstant(self):
localctx = Fortran90Parser.BozLiteralConstantContext(self, self._ctx, self.state)
self.enterRule(localctx, 286, self.RULE_bozLiteralConstant)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1870
_la = self._input.LA(1)
if not(((((_la - 174)) & ~0x3f) == 0 and ((1 << (_la - 174)) & ((1 << (Fortran90Parser.ZCON - 174)) | (1 << (Fortran90Parser.BCON - 174)) | (1 << (Fortran90Parser.OCON - 174)))) != 0)):
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 StructureConstructorContext(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(Fortran90Parser.TypeNameContext,0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def exprList(self):
return self.getTypedRuleContext(Fortran90Parser.ExprListContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_structureConstructor
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterStructureConstructor" ):
listener.enterStructureConstructor(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitStructureConstructor" ):
listener.exitStructureConstructor(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitStructureConstructor" ):
return visitor.visitStructureConstructor(self)
else:
return visitor.visitChildren(self)
[docs]
def structureConstructor(self):
localctx = Fortran90Parser.StructureConstructorContext(self, self._ctx, self.state)
self.enterRule(localctx, 288, self.RULE_structureConstructor)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1872
self.typeName()
self.state = 1873
self.match(Fortran90Parser.LPAREN)
self.state = 1874
self.exprList()
self.state = 1875
self.match(Fortran90Parser.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 ExprListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def expression(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.ExpressionContext)
else:
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,i)
[docs]
def COMMA(self):
return self.getToken(Fortran90Parser.COMMA, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_exprList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterExprList" ):
listener.enterExprList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitExprList" ):
listener.exitExprList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitExprList" ):
return visitor.visitExprList(self)
else:
return visitor.visitChildren(self)
[docs]
def exprList(self):
localctx = Fortran90Parser.ExprListContext(self, self._ctx, self.state)
self.enterRule(localctx, 290, self.RULE_exprList)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1877
self.expression(0)
self.state = 1878
self.match(Fortran90Parser.COMMA)
self.state = 1879
self.expression(0)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class NamedConstantUseContext(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(Fortran90Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_namedConstantUse
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterNamedConstantUse" ):
listener.enterNamedConstantUse(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitNamedConstantUse" ):
listener.exitNamedConstantUse(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNamedConstantUse" ):
return visitor.visitNamedConstantUse(self)
else:
return visitor.visitChildren(self)
[docs]
def namedConstantUse(self):
localctx = Fortran90Parser.NamedConstantUseContext(self, self._ctx, self.state)
self.enterRule(localctx, 292, self.RULE_namedConstantUse)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1881
self.match(Fortran90Parser.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 TypeParamValueContext(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(Fortran90Parser.ExpressionContext,0)
[docs]
def STAR(self):
return self.getToken(Fortran90Parser.STAR, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_typeParamValue
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTypeParamValue" ):
listener.enterTypeParamValue(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTypeParamValue" ):
listener.exitTypeParamValue(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTypeParamValue" ):
return visitor.visitTypeParamValue(self)
else:
return visitor.visitChildren(self)
[docs]
def typeParamValue(self):
localctx = Fortran90Parser.TypeParamValueContext(self, self._ctx, self.state)
self.enterRule(localctx, 294, self.RULE_typeParamValue)
try:
self.state = 1885
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.DOP, Fortran90Parser.REAL, Fortran90Parser.SIZE, Fortran90Parser.LPAREN, Fortran90Parser.MINUS, Fortran90Parser.PLUS, Fortran90Parser.LNOT, Fortran90Parser.TRUE, Fortran90Parser.FALSE, Fortran90Parser.OBRACKETSLASH, Fortran90Parser.SCON, Fortran90Parser.RDCON, Fortran90Parser.ICON, Fortran90Parser.NAME]:
self.enterOuterAlt(localctx, 1)
self.state = 1883
self.expression(0)
pass
elif token in [Fortran90Parser.STAR]:
self.enterOuterAlt(localctx, 2)
self.state = 1884
self.match(Fortran90Parser.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 ModuleStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def MODULE(self):
return self.getToken(Fortran90Parser.MODULE, 0)
[docs]
def moduleName(self):
return self.getTypedRuleContext(Fortran90Parser.ModuleNameContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_moduleStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterModuleStmt" ):
listener.enterModuleStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitModuleStmt" ):
listener.exitModuleStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitModuleStmt" ):
return visitor.visitModuleStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def moduleStmt(self):
localctx = Fortran90Parser.ModuleStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 296, self.RULE_moduleStmt)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1887
self.match(Fortran90Parser.MODULE)
self.state = 1888
self.moduleName()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ModuleNameContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ident(self):
return self.getTypedRuleContext(Fortran90Parser.IdentContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_moduleName
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterModuleName" ):
listener.enterModuleName(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitModuleName" ):
listener.exitModuleName(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitModuleName" ):
return visitor.visitModuleName(self)
else:
return visitor.visitChildren(self)
[docs]
def moduleName(self):
localctx = Fortran90Parser.ModuleNameContext(self, self._ctx, self.state)
self.enterRule(localctx, 298, self.RULE_moduleName)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1890
self.ident()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class IdentContext(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(Fortran90Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_ident
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIdent" ):
listener.enterIdent(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIdent" ):
listener.exitIdent(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIdent" ):
return visitor.visitIdent(self)
else:
return visitor.visitChildren(self)
[docs]
def ident(self):
localctx = Fortran90Parser.IdentContext(self, self._ctx, self.state)
self.enterRule(localctx, 300, self.RULE_ident)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1892
self.match(Fortran90Parser.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 ModuleBodyContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_moduleBody
[docs]
def copyFrom(self, ctx:ParserRuleContext):
super().copyFrom(ctx)
[docs]
class ComplexSubmoduleContext(ModuleBodyContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a Fortran90Parser.ModuleBodyContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def moduleBody(self):
return self.getTypedRuleContext(Fortran90Parser.ModuleBodyContext,0)
[docs]
def moduleSubprogramPartConstruct(self):
return self.getTypedRuleContext(Fortran90Parser.ModuleSubprogramPartConstructContext,0)
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterComplexSubmodule" ):
listener.enterComplexSubmodule(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitComplexSubmodule" ):
listener.exitComplexSubmodule(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitComplexSubmodule" ):
return visitor.visitComplexSubmodule(self)
else:
return visitor.visitChildren(self)
[docs]
class ComplexSpecPartContext(ModuleBodyContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a Fortran90Parser.ModuleBodyContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def moduleBody(self):
return self.getTypedRuleContext(Fortran90Parser.ModuleBodyContext,0)
[docs]
def specificationPartConstruct(self):
return self.getTypedRuleContext(Fortran90Parser.SpecificationPartConstructContext,0)
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterComplexSpecPart" ):
listener.enterComplexSpecPart(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitComplexSpecPart" ):
listener.exitComplexSpecPart(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitComplexSpecPart" ):
return visitor.visitComplexSpecPart(self)
else:
return visitor.visitChildren(self)
[docs]
class SubmoduleStmtContext(ModuleBodyContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a Fortran90Parser.ModuleBodyContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def moduleSubprogramPartConstruct(self):
return self.getTypedRuleContext(Fortran90Parser.ModuleSubprogramPartConstructContext,0)
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSubmoduleStmt" ):
listener.enterSubmoduleStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSubmoduleStmt" ):
listener.exitSubmoduleStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSubmoduleStmt" ):
return visitor.visitSubmoduleStmt(self)
else:
return visitor.visitChildren(self)
[docs]
class SpecPartStmtContext(ModuleBodyContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a Fortran90Parser.ModuleBodyContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def specificationPartConstruct(self):
return self.getTypedRuleContext(Fortran90Parser.SpecificationPartConstructContext,0)
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSpecPartStmt" ):
listener.enterSpecPartStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSpecPartStmt" ):
listener.exitSpecPartStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSpecPartStmt" ):
return visitor.visitSpecPartStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def moduleBody(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = Fortran90Parser.ModuleBodyContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 302
self.enterRecursionRule(localctx, 302, self.RULE_moduleBody, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1897
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,129,self._ctx)
if la_ == 1:
localctx = Fortran90Parser.SpecPartStmtContext(self, localctx)
self._ctx = localctx
_prevctx = localctx
self.state = 1895
self.specificationPartConstruct()
pass
elif la_ == 2:
localctx = Fortran90Parser.SubmoduleStmtContext(self, localctx)
self._ctx = localctx
_prevctx = localctx
self.state = 1896
self.moduleSubprogramPartConstruct()
pass
self._ctx.stop = self._input.LT(-1)
self.state = 1905
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,131,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
self.state = 1903
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,130,self._ctx)
if la_ == 1:
localctx = Fortran90Parser.ComplexSpecPartContext(self, Fortran90Parser.ModuleBodyContext(self, _parentctx, _parentState))
self.pushNewRecursionContext(localctx, _startState, self.RULE_moduleBody)
self.state = 1899
if not self.precpred(self._ctx, 2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
self.state = 1900
self.specificationPartConstruct()
pass
elif la_ == 2:
localctx = Fortran90Parser.ComplexSubmoduleContext(self, Fortran90Parser.ModuleBodyContext(self, _parentctx, _parentState))
self.pushNewRecursionContext(localctx, _startState, self.RULE_moduleBody)
self.state = 1901
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 1902
self.moduleSubprogramPartConstruct()
pass
self.state = 1907
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,131,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class ModuleSubprogramPartConstructContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def containsStmt(self):
return self.getTypedRuleContext(Fortran90Parser.ContainsStmtContext,0)
[docs]
def moduleSubprogram(self):
return self.getTypedRuleContext(Fortran90Parser.ModuleSubprogramContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_moduleSubprogramPartConstruct
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterModuleSubprogramPartConstruct" ):
listener.enterModuleSubprogramPartConstruct(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitModuleSubprogramPartConstruct" ):
listener.exitModuleSubprogramPartConstruct(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitModuleSubprogramPartConstruct" ):
return visitor.visitModuleSubprogramPartConstruct(self)
else:
return visitor.visitChildren(self)
[docs]
def moduleSubprogramPartConstruct(self):
localctx = Fortran90Parser.ModuleSubprogramPartConstructContext(self, self._ctx, self.state)
self.enterRule(localctx, 304, self.RULE_moduleSubprogramPartConstruct)
try:
self.state = 1910
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.CONTAINS]:
self.enterOuterAlt(localctx, 1)
self.state = 1908
self.containsStmt()
pass
elif token in [Fortran90Parser.RECURSIVE, Fortran90Parser.FUNCTION, Fortran90Parser.SUBROUTINE, Fortran90Parser.DOUBLEPRECISION, Fortran90Parser.REAL, Fortran90Parser.CHARACTER, Fortran90Parser.DOUBLE, Fortran90Parser.COMPLEX, Fortran90Parser.INTEGER, Fortran90Parser.LOGICAL, Fortran90Parser.TYPE]:
self.enterOuterAlt(localctx, 2)
self.state = 1909
self.moduleSubprogram()
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 ContainsStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def CONTAINS(self):
return self.getToken(Fortran90Parser.CONTAINS, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_containsStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterContainsStmt" ):
listener.enterContainsStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitContainsStmt" ):
listener.exitContainsStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitContainsStmt" ):
return visitor.visitContainsStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def containsStmt(self):
localctx = Fortran90Parser.ContainsStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 306, self.RULE_containsStmt)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1912
self.match(Fortran90Parser.CONTAINS)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ModuleSubprogramContext(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(Fortran90Parser.FunctionSubprogramContext,0)
[docs]
def subroutineSubprogram(self):
return self.getTypedRuleContext(Fortran90Parser.SubroutineSubprogramContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_moduleSubprogram
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterModuleSubprogram" ):
listener.enterModuleSubprogram(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitModuleSubprogram" ):
listener.exitModuleSubprogram(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitModuleSubprogram" ):
return visitor.visitModuleSubprogram(self)
else:
return visitor.visitChildren(self)
[docs]
def moduleSubprogram(self):
localctx = Fortran90Parser.ModuleSubprogramContext(self, self._ctx, self.state)
self.enterRule(localctx, 308, self.RULE_moduleSubprogram)
try:
self.state = 1916
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,133,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1914
self.functionSubprogram()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1915
self.subroutineSubprogram()
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 FunctionSubprogramContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def functionPrefix(self):
return self.getTypedRuleContext(Fortran90Parser.FunctionPrefixContext,0)
[docs]
def functionName(self):
return self.getTypedRuleContext(Fortran90Parser.FunctionNameContext,0)
[docs]
def functionRange(self):
return self.getTypedRuleContext(Fortran90Parser.FunctionRangeContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.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 = Fortran90Parser.FunctionSubprogramContext(self, self._ctx, self.state)
self.enterRule(localctx, 310, self.RULE_functionSubprogram)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1918
self.functionPrefix()
self.state = 1919
self.functionName()
self.state = 1920
self.functionRange()
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(Fortran90Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.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 = Fortran90Parser.FunctionNameContext(self, self._ctx, self.state)
self.enterRule(localctx, 312, self.RULE_functionName)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1922
self.match(Fortran90Parser.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 FunctionRangeContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def functionParList(self):
return self.getTypedRuleContext(Fortran90Parser.FunctionParListContext,0)
[docs]
def endFunctionStmt(self):
return self.getTypedRuleContext(Fortran90Parser.EndFunctionStmtContext,0)
[docs]
def body(self):
return self.getTypedRuleContext(Fortran90Parser.BodyContext,0)
[docs]
def RESULT(self):
return self.getToken(Fortran90Parser.RESULT, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def NAME(self):
return self.getToken(Fortran90Parser.NAME, 0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def bodyPlusInternals(self):
return self.getTypedRuleContext(Fortran90Parser.BodyPlusInternalsContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_functionRange
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterFunctionRange" ):
listener.enterFunctionRange(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitFunctionRange" ):
listener.exitFunctionRange(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFunctionRange" ):
return visitor.visitFunctionRange(self)
else:
return visitor.visitChildren(self)
[docs]
def functionRange(self):
localctx = Fortran90Parser.FunctionRangeContext(self, self._ctx, self.state)
self.enterRule(localctx, 314, self.RULE_functionRange)
try:
self.state = 1952
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,136,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1924
self.functionParList()
self.state = 1926
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,134,self._ctx)
if la_ == 1:
self.state = 1925
self.body()
self.state = 1928
self.endFunctionStmt()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1930
self.functionParList()
self.state = 1931
self.match(Fortran90Parser.RESULT)
self.state = 1932
self.match(Fortran90Parser.LPAREN)
self.state = 1933
self.match(Fortran90Parser.NAME)
self.state = 1934
self.match(Fortran90Parser.RPAREN)
self.state = 1936
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,135,self._ctx)
if la_ == 1:
self.state = 1935
self.body()
self.state = 1938
self.endFunctionStmt()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 1940
self.functionParList()
self.state = 1941
self.match(Fortran90Parser.RESULT)
self.state = 1942
self.match(Fortran90Parser.LPAREN)
self.state = 1943
self.match(Fortran90Parser.NAME)
self.state = 1944
self.match(Fortran90Parser.RPAREN)
self.state = 1945
self.bodyPlusInternals(0)
self.state = 1946
self.endFunctionStmt()
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 1948
self.functionParList()
self.state = 1949
self.bodyPlusInternals(0)
self.state = 1950
self.endFunctionStmt()
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 BodyContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def bodyConstruct(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.BodyConstructContext)
else:
return self.getTypedRuleContext(Fortran90Parser.BodyConstructContext,i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_body
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterBody" ):
listener.enterBody(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitBody" ):
listener.exitBody(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitBody" ):
return visitor.visitBody(self)
else:
return visitor.visitChildren(self)
[docs]
def body(self):
localctx = Fortran90Parser.BodyContext(self, self._ctx, self.state)
self.enterRule(localctx, 316, self.RULE_body)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1955
self._errHandler.sync(self)
_alt = 1
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 1954
self.bodyConstruct()
else:
raise NoViableAltException(self)
self.state = 1957
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,137,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 BodyConstructContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def specificationPartConstruct(self):
return self.getTypedRuleContext(Fortran90Parser.SpecificationPartConstructContext,0)
[docs]
def executableConstruct(self):
return self.getTypedRuleContext(Fortran90Parser.ExecutableConstructContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_bodyConstruct
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterBodyConstruct" ):
listener.enterBodyConstruct(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitBodyConstruct" ):
listener.exitBodyConstruct(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitBodyConstruct" ):
return visitor.visitBodyConstruct(self)
else:
return visitor.visitChildren(self)
[docs]
def bodyConstruct(self):
localctx = Fortran90Parser.BodyConstructContext(self, self._ctx, self.state)
self.enterRule(localctx, 318, self.RULE_bodyConstruct)
try:
self.state = 1961
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,138,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1959
self.specificationPartConstruct()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1960
self.executableConstruct()
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 ExecutableConstructContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def actionStmt(self):
return self.getTypedRuleContext(Fortran90Parser.ActionStmtContext,0)
[docs]
def doConstruct(self):
return self.getTypedRuleContext(Fortran90Parser.DoConstructContext,0)
[docs]
def ifConstruct(self):
return self.getTypedRuleContext(Fortran90Parser.IfConstructContext,0)
[docs]
def caseConstruct(self):
return self.getTypedRuleContext(Fortran90Parser.CaseConstructContext,0)
[docs]
def whereConstruct(self):
return self.getTypedRuleContext(Fortran90Parser.WhereConstructContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_executableConstruct
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterExecutableConstruct" ):
listener.enterExecutableConstruct(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitExecutableConstruct" ):
listener.exitExecutableConstruct(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitExecutableConstruct" ):
return visitor.visitExecutableConstruct(self)
else:
return visitor.visitChildren(self)
[docs]
def executableConstruct(self):
localctx = Fortran90Parser.ExecutableConstructContext(self, self._ctx, self.state)
self.enterRule(localctx, 320, self.RULE_executableConstruct)
try:
self.state = 1968
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,139,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1963
self.actionStmt()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1964
self.doConstruct()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 1965
self.ifConstruct()
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 1966
self.caseConstruct()
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 1967
self.whereConstruct()
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 WhereConstructContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def where(self):
return self.getTypedRuleContext(Fortran90Parser.WhereContext,0)
[docs]
def endWhereStmt(self):
return self.getTypedRuleContext(Fortran90Parser.EndWhereStmtContext,0)
[docs]
def elseWhere(self):
return self.getTypedRuleContext(Fortran90Parser.ElseWhereContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_whereConstruct
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterWhereConstruct" ):
listener.enterWhereConstruct(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitWhereConstruct" ):
listener.exitWhereConstruct(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitWhereConstruct" ):
return visitor.visitWhereConstruct(self)
else:
return visitor.visitChildren(self)
[docs]
def whereConstruct(self):
localctx = Fortran90Parser.WhereConstructContext(self, self._ctx, self.state)
self.enterRule(localctx, 322, self.RULE_whereConstruct)
try:
self.state = 1976
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,140,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1970
self.where(0)
self.state = 1971
self.endWhereStmt()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1973
self.elseWhere(0)
self.state = 1974
self.endWhereStmt()
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 ElseWhereContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def where(self):
return self.getTypedRuleContext(Fortran90Parser.WhereContext,0)
[docs]
def elsewhereStmt(self):
return self.getTypedRuleContext(Fortran90Parser.ElsewhereStmtContext,0)
[docs]
def elseWhere(self):
return self.getTypedRuleContext(Fortran90Parser.ElseWhereContext,0)
[docs]
def assignmentStmt(self):
return self.getTypedRuleContext(Fortran90Parser.AssignmentStmtContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_elseWhere
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterElseWhere" ):
listener.enterElseWhere(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitElseWhere" ):
listener.exitElseWhere(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitElseWhere" ):
return visitor.visitElseWhere(self)
else:
return visitor.visitChildren(self)
[docs]
def elseWhere(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = Fortran90Parser.ElseWhereContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 324
self.enterRecursionRule(localctx, 324, self.RULE_elseWhere, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1979
self.where(0)
self.state = 1980
self.elsewhereStmt()
self._ctx.stop = self._input.LT(-1)
self.state = 1986
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,141,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = Fortran90Parser.ElseWhereContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_elseWhere)
self.state = 1982
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 1983
self.assignmentStmt()
self.state = 1988
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,141,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class ElsewhereStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ELSEWHERE(self):
return self.getToken(Fortran90Parser.ELSEWHERE, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_elsewhereStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterElsewhereStmt" ):
listener.enterElsewhereStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitElsewhereStmt" ):
listener.exitElsewhereStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitElsewhereStmt" ):
return visitor.visitElsewhereStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def elsewhereStmt(self):
localctx = Fortran90Parser.ElsewhereStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 326, self.RULE_elsewhereStmt)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1989
self.match(Fortran90Parser.ELSEWHERE)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class EndWhereStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ENDWHERE(self):
return self.getToken(Fortran90Parser.ENDWHERE, 0)
[docs]
def END(self):
return self.getToken(Fortran90Parser.END, 0)
[docs]
def WHERE(self):
return self.getToken(Fortran90Parser.WHERE, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_endWhereStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEndWhereStmt" ):
listener.enterEndWhereStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEndWhereStmt" ):
listener.exitEndWhereStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEndWhereStmt" ):
return visitor.visitEndWhereStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def endWhereStmt(self):
localctx = Fortran90Parser.EndWhereStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 328, self.RULE_endWhereStmt)
try:
self.state = 1994
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.ENDWHERE]:
self.enterOuterAlt(localctx, 1)
self.state = 1991
self.match(Fortran90Parser.ENDWHERE)
pass
elif token in [Fortran90Parser.END]:
self.enterOuterAlt(localctx, 2)
self.state = 1992
self.match(Fortran90Parser.END)
self.state = 1993
self.match(Fortran90Parser.WHERE)
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 WhereContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def whereConstructStmt(self):
return self.getTypedRuleContext(Fortran90Parser.WhereConstructStmtContext,0)
[docs]
def where(self):
return self.getTypedRuleContext(Fortran90Parser.WhereContext,0)
[docs]
def assignmentStmt(self):
return self.getTypedRuleContext(Fortran90Parser.AssignmentStmtContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_where
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterWhere" ):
listener.enterWhere(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitWhere" ):
listener.exitWhere(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitWhere" ):
return visitor.visitWhere(self)
else:
return visitor.visitChildren(self)
[docs]
def where(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = Fortran90Parser.WhereContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 330
self.enterRecursionRule(localctx, 330, self.RULE_where, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1997
self.whereConstructStmt()
self._ctx.stop = self._input.LT(-1)
self.state = 2003
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,143,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = Fortran90Parser.WhereContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_where)
self.state = 1999
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 2000
self.assignmentStmt()
self.state = 2005
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,143,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class WhereConstructStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def WHERE(self):
return self.getToken(Fortran90Parser.WHERE, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def maskExpr(self):
return self.getTypedRuleContext(Fortran90Parser.MaskExprContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_whereConstructStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterWhereConstructStmt" ):
listener.enterWhereConstructStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitWhereConstructStmt" ):
listener.exitWhereConstructStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitWhereConstructStmt" ):
return visitor.visitWhereConstructStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def whereConstructStmt(self):
localctx = Fortran90Parser.WhereConstructStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 332, self.RULE_whereConstructStmt)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2006
self.match(Fortran90Parser.WHERE)
self.state = 2007
self.match(Fortran90Parser.LPAREN)
self.state = 2008
self.maskExpr()
self.state = 2009
self.match(Fortran90Parser.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 MaskExprContext(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(Fortran90Parser.ExpressionContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_maskExpr
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterMaskExpr" ):
listener.enterMaskExpr(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitMaskExpr" ):
listener.exitMaskExpr(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitMaskExpr" ):
return visitor.visitMaskExpr(self)
else:
return visitor.visitChildren(self)
[docs]
def maskExpr(self):
localctx = Fortran90Parser.MaskExprContext(self, self._ctx, self.state)
self.enterRule(localctx, 334, self.RULE_maskExpr)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2011
self.expression(0)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class CaseConstructContext(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(Fortran90Parser.NAME, 0)
[docs]
def COLON(self):
return self.getToken(Fortran90Parser.COLON, 0)
[docs]
def SELECTCASE(self):
return self.getToken(Fortran90Parser.SELECTCASE, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def selectCaseRange(self):
return self.getTypedRuleContext(Fortran90Parser.SelectCaseRangeContext,0)
[docs]
def SELECT(self):
return self.getToken(Fortran90Parser.SELECT, 0)
[docs]
def CASE(self):
return self.getToken(Fortran90Parser.CASE, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_caseConstruct
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCaseConstruct" ):
listener.enterCaseConstruct(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCaseConstruct" ):
listener.exitCaseConstruct(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCaseConstruct" ):
return visitor.visitCaseConstruct(self)
else:
return visitor.visitChildren(self)
[docs]
def caseConstruct(self):
localctx = Fortran90Parser.CaseConstructContext(self, self._ctx, self.state)
self.enterRule(localctx, 336, self.RULE_caseConstruct)
try:
self.state = 2043
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,144,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2013
self.match(Fortran90Parser.NAME)
self.state = 2014
self.match(Fortran90Parser.COLON)
self.state = 2015
self.match(Fortran90Parser.SELECTCASE)
self.state = 2016
self.match(Fortran90Parser.LPAREN)
self.state = 2017
self.expression(0)
self.state = 2018
self.match(Fortran90Parser.RPAREN)
self.state = 2019
self.selectCaseRange()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2021
self.match(Fortran90Parser.SELECTCASE)
self.state = 2022
self.match(Fortran90Parser.LPAREN)
self.state = 2023
self.expression(0)
self.state = 2024
self.match(Fortran90Parser.RPAREN)
self.state = 2025
self.selectCaseRange()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 2027
self.match(Fortran90Parser.NAME)
self.state = 2028
self.match(Fortran90Parser.COLON)
self.state = 2029
self.match(Fortran90Parser.SELECT)
self.state = 2030
self.match(Fortran90Parser.CASE)
self.state = 2031
self.match(Fortran90Parser.LPAREN)
self.state = 2032
self.expression(0)
self.state = 2033
self.match(Fortran90Parser.RPAREN)
self.state = 2034
self.selectCaseRange()
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 2036
self.match(Fortran90Parser.SELECT)
self.state = 2037
self.match(Fortran90Parser.CASE)
self.state = 2038
self.match(Fortran90Parser.LPAREN)
self.state = 2039
self.expression(0)
self.state = 2040
self.match(Fortran90Parser.RPAREN)
self.state = 2041
self.selectCaseRange()
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 SelectCaseRangeContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def selectCaseBody(self):
return self.getTypedRuleContext(Fortran90Parser.SelectCaseBodyContext,0)
[docs]
def endSelectStmt(self):
return self.getTypedRuleContext(Fortran90Parser.EndSelectStmtContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_selectCaseRange
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSelectCaseRange" ):
listener.enterSelectCaseRange(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSelectCaseRange" ):
listener.exitSelectCaseRange(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSelectCaseRange" ):
return visitor.visitSelectCaseRange(self)
else:
return visitor.visitChildren(self)
[docs]
def selectCaseRange(self):
localctx = Fortran90Parser.SelectCaseRangeContext(self, self._ctx, self.state)
self.enterRule(localctx, 338, self.RULE_selectCaseRange)
try:
self.state = 2049
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.CASE]:
self.enterOuterAlt(localctx, 1)
self.state = 2045
self.selectCaseBody(0)
self.state = 2046
self.endSelectStmt()
pass
elif token in [Fortran90Parser.END, Fortran90Parser.ENDSELECT]:
self.enterOuterAlt(localctx, 2)
self.state = 2048
self.endSelectStmt()
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 EndSelectStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ENDSELECT(self):
return self.getToken(Fortran90Parser.ENDSELECT, 0)
[docs]
def NAME(self):
return self.getToken(Fortran90Parser.NAME, 0)
[docs]
def END(self):
return self.getToken(Fortran90Parser.END, 0)
[docs]
def SELECT(self):
return self.getToken(Fortran90Parser.SELECT, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_endSelectStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEndSelectStmt" ):
listener.enterEndSelectStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEndSelectStmt" ):
listener.exitEndSelectStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEndSelectStmt" ):
return visitor.visitEndSelectStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def endSelectStmt(self):
localctx = Fortran90Parser.EndSelectStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 340, self.RULE_endSelectStmt)
try:
self.state = 2060
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.ENDSELECT]:
self.enterOuterAlt(localctx, 1)
self.state = 2051
self.match(Fortran90Parser.ENDSELECT)
self.state = 2053
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,146,self._ctx)
if la_ == 1:
self.state = 2052
self.match(Fortran90Parser.NAME)
pass
elif token in [Fortran90Parser.END]:
self.enterOuterAlt(localctx, 2)
self.state = 2055
self.match(Fortran90Parser.END)
self.state = 2056
self.match(Fortran90Parser.SELECT)
self.state = 2058
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,147,self._ctx)
if la_ == 1:
self.state = 2057
self.match(Fortran90Parser.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 SelectCaseBodyContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def caseStmt(self):
return self.getTypedRuleContext(Fortran90Parser.CaseStmtContext,0)
[docs]
def selectCaseBody(self):
return self.getTypedRuleContext(Fortran90Parser.SelectCaseBodyContext,0)
[docs]
def caseBodyConstruct(self):
return self.getTypedRuleContext(Fortran90Parser.CaseBodyConstructContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_selectCaseBody
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSelectCaseBody" ):
listener.enterSelectCaseBody(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSelectCaseBody" ):
listener.exitSelectCaseBody(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSelectCaseBody" ):
return visitor.visitSelectCaseBody(self)
else:
return visitor.visitChildren(self)
[docs]
def selectCaseBody(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = Fortran90Parser.SelectCaseBodyContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 342
self.enterRecursionRule(localctx, 342, self.RULE_selectCaseBody, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2063
self.caseStmt()
self._ctx.stop = self._input.LT(-1)
self.state = 2069
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,149,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = Fortran90Parser.SelectCaseBodyContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_selectCaseBody)
self.state = 2065
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 2066
self.caseBodyConstruct()
self.state = 2071
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,149,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class CaseBodyConstructContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def caseStmt(self):
return self.getTypedRuleContext(Fortran90Parser.CaseStmtContext,0)
[docs]
def executionPartConstruct(self):
return self.getTypedRuleContext(Fortran90Parser.ExecutionPartConstructContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_caseBodyConstruct
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCaseBodyConstruct" ):
listener.enterCaseBodyConstruct(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCaseBodyConstruct" ):
listener.exitCaseBodyConstruct(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCaseBodyConstruct" ):
return visitor.visitCaseBodyConstruct(self)
else:
return visitor.visitChildren(self)
[docs]
def caseBodyConstruct(self):
localctx = Fortran90Parser.CaseBodyConstructContext(self, self._ctx, self.state)
self.enterRule(localctx, 344, self.RULE_caseBodyConstruct)
try:
self.state = 2074
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.CASE]:
self.enterOuterAlt(localctx, 1)
self.state = 2072
self.caseStmt()
pass
elif token in [Fortran90Parser.ENTRY, Fortran90Parser.END, Fortran90Parser.ASSIGNSTMT, Fortran90Parser.DATA, Fortran90Parser.GO, Fortran90Parser.GOTO, Fortran90Parser.IF, Fortran90Parser.DO, Fortran90Parser.CONTINUE, Fortran90Parser.WHERE, Fortran90Parser.SELECTCASE, Fortran90Parser.SELECT, Fortran90Parser.STOP, Fortran90Parser.PAUSE, Fortran90Parser.WRITE, Fortran90Parser.READ, Fortran90Parser.PRINT, Fortran90Parser.OPEN, Fortran90Parser.CALL, Fortran90Parser.RETURN, Fortran90Parser.CLOSE, Fortran90Parser.INQUIRE, Fortran90Parser.BACKSPACE, Fortran90Parser.ENDFILE, Fortran90Parser.REWIND, Fortran90Parser.ALLOCATE, Fortran90Parser.DEALLOCATE, Fortran90Parser.NULLIFY, Fortran90Parser.CYCLE, Fortran90Parser.ICON, Fortran90Parser.NAME, Fortran90Parser.EXIT]:
self.enterOuterAlt(localctx, 2)
self.state = 2073
self.executionPartConstruct()
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 CaseStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def CASE(self):
return self.getToken(Fortran90Parser.CASE, 0)
[docs]
def caseSelector(self):
return self.getTypedRuleContext(Fortran90Parser.CaseSelectorContext,0)
[docs]
def NAME(self):
return self.getToken(Fortran90Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_caseStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCaseStmt" ):
listener.enterCaseStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCaseStmt" ):
listener.exitCaseStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCaseStmt" ):
return visitor.visitCaseStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def caseStmt(self):
localctx = Fortran90Parser.CaseStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 346, self.RULE_caseStmt)
try:
self.state = 2082
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,151,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2076
self.match(Fortran90Parser.CASE)
self.state = 2077
self.caseSelector()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2078
self.match(Fortran90Parser.CASE)
self.state = 2079
self.caseSelector()
self.state = 2080
self.match(Fortran90Parser.NAME)
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 CaseSelectorContext(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(Fortran90Parser.LPAREN, 0)
[docs]
def caseValueRangeList(self):
return self.getTypedRuleContext(Fortran90Parser.CaseValueRangeListContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def DEFAULT(self):
return self.getToken(Fortran90Parser.DEFAULT, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_caseSelector
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCaseSelector" ):
listener.enterCaseSelector(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCaseSelector" ):
listener.exitCaseSelector(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCaseSelector" ):
return visitor.visitCaseSelector(self)
else:
return visitor.visitChildren(self)
[docs]
def caseSelector(self):
localctx = Fortran90Parser.CaseSelectorContext(self, self._ctx, self.state)
self.enterRule(localctx, 348, self.RULE_caseSelector)
try:
self.state = 2089
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.LPAREN]:
self.enterOuterAlt(localctx, 1)
self.state = 2084
self.match(Fortran90Parser.LPAREN)
self.state = 2085
self.caseValueRangeList()
self.state = 2086
self.match(Fortran90Parser.RPAREN)
pass
elif token in [Fortran90Parser.DEFAULT]:
self.enterOuterAlt(localctx, 2)
self.state = 2088
self.match(Fortran90Parser.DEFAULT)
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 CaseValueRangeListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def caseValueRange(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.CaseValueRangeContext)
else:
return self.getTypedRuleContext(Fortran90Parser.CaseValueRangeContext,i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_caseValueRangeList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCaseValueRangeList" ):
listener.enterCaseValueRangeList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCaseValueRangeList" ):
listener.exitCaseValueRangeList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCaseValueRangeList" ):
return visitor.visitCaseValueRangeList(self)
else:
return visitor.visitChildren(self)
[docs]
def caseValueRangeList(self):
localctx = Fortran90Parser.CaseValueRangeListContext(self, self._ctx, self.state)
self.enterRule(localctx, 350, self.RULE_caseValueRangeList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 2092
self._errHandler.sync(self)
_la = self._input.LA(1)
while True:
self.state = 2091
self.caseValueRange()
self.state = 2094
self._errHandler.sync(self)
_la = self._input.LA(1)
if not (_la==Fortran90Parser.DOP or _la==Fortran90Parser.REAL or ((((_la - 84)) & ~0x3f) == 0 and ((1 << (_la - 84)) & ((1 << (Fortran90Parser.SIZE - 84)) | (1 << (Fortran90Parser.LPAREN - 84)) | (1 << (Fortran90Parser.COLON - 84)) | (1 << (Fortran90Parser.MINUS - 84)) | (1 << (Fortran90Parser.PLUS - 84)) | (1 << (Fortran90Parser.LNOT - 84)))) != 0) or ((((_la - 149)) & ~0x3f) == 0 and ((1 << (_la - 149)) & ((1 << (Fortran90Parser.TRUE - 149)) | (1 << (Fortran90Parser.FALSE - 149)) | (1 << (Fortran90Parser.OBRACKETSLASH - 149)) | (1 << (Fortran90Parser.SCON - 149)) | (1 << (Fortran90Parser.RDCON - 149)) | (1 << (Fortran90Parser.ICON - 149)) | (1 << (Fortran90Parser.NAME - 149)))) != 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 CaseValueRangeContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_caseValueRange
[docs]
def copyFrom(self, ctx:ParserRuleContext):
super().copyFrom(ctx)
[docs]
class MidlleColonExpressionContext(CaseValueRangeContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a Fortran90Parser.CaseValueRangeContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def expression(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.ExpressionContext)
else:
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,i)
[docs]
def COLON(self):
return self.getToken(Fortran90Parser.COLON, 0)
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterMidlleColonExpression" ):
listener.enterMidlleColonExpression(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitMidlleColonExpression" ):
listener.exitMidlleColonExpression(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitMidlleColonExpression" ):
return visitor.visitMidlleColonExpression(self)
else:
return visitor.visitChildren(self)
[docs]
class LitteralExpressionContext(CaseValueRangeContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a Fortran90Parser.CaseValueRangeContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,0)
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLitteralExpression" ):
listener.enterLitteralExpression(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLitteralExpression" ):
listener.exitLitteralExpression(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLitteralExpression" ):
return visitor.visitLitteralExpression(self)
else:
return visitor.visitChildren(self)
[docs]
class AfterColonExpressionContext(CaseValueRangeContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a Fortran90Parser.CaseValueRangeContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,0)
[docs]
def COLON(self):
return self.getToken(Fortran90Parser.COLON, 0)
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAfterColonExpression" ):
listener.enterAfterColonExpression(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAfterColonExpression" ):
listener.exitAfterColonExpression(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAfterColonExpression" ):
return visitor.visitAfterColonExpression(self)
else:
return visitor.visitChildren(self)
[docs]
class BeforeColonExpressionContext(CaseValueRangeContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a Fortran90Parser.CaseValueRangeContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def COLON(self):
return self.getToken(Fortran90Parser.COLON, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,0)
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterBeforeColonExpression" ):
listener.enterBeforeColonExpression(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitBeforeColonExpression" ):
listener.exitBeforeColonExpression(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitBeforeColonExpression" ):
return visitor.visitBeforeColonExpression(self)
else:
return visitor.visitChildren(self)
[docs]
def caseValueRange(self):
localctx = Fortran90Parser.CaseValueRangeContext(self, self._ctx, self.state)
self.enterRule(localctx, 352, self.RULE_caseValueRange)
try:
self.state = 2106
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,154,self._ctx)
if la_ == 1:
localctx = Fortran90Parser.LitteralExpressionContext(self, localctx)
self.enterOuterAlt(localctx, 1)
self.state = 2096
self.expression(0)
pass
elif la_ == 2:
localctx = Fortran90Parser.AfterColonExpressionContext(self, localctx)
self.enterOuterAlt(localctx, 2)
self.state = 2097
self.expression(0)
self.state = 2098
self.match(Fortran90Parser.COLON)
pass
elif la_ == 3:
localctx = Fortran90Parser.BeforeColonExpressionContext(self, localctx)
self.enterOuterAlt(localctx, 3)
self.state = 2100
self.match(Fortran90Parser.COLON)
self.state = 2101
self.expression(0)
pass
elif la_ == 4:
localctx = Fortran90Parser.MidlleColonExpressionContext(self, localctx)
self.enterOuterAlt(localctx, 4)
self.state = 2102
self.expression(0)
self.state = 2103
self.match(Fortran90Parser.COLON)
self.state = 2104
self.expression(0)
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 IfConstructContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ifThenStmt(self):
return self.getTypedRuleContext(Fortran90Parser.IfThenStmtContext,0)
[docs]
def conditionalBody(self):
return self.getTypedRuleContext(Fortran90Parser.ConditionalBodyContext,0)
[docs]
def endIfStmt(self):
return self.getTypedRuleContext(Fortran90Parser.EndIfStmtContext,0)
[docs]
def elseIfConstruct(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.ElseIfConstructContext)
else:
return self.getTypedRuleContext(Fortran90Parser.ElseIfConstructContext,i)
[docs]
def elseConstruct(self):
return self.getTypedRuleContext(Fortran90Parser.ElseConstructContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_ifConstruct
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIfConstruct" ):
listener.enterIfConstruct(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIfConstruct" ):
listener.exitIfConstruct(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIfConstruct" ):
return visitor.visitIfConstruct(self)
else:
return visitor.visitChildren(self)
[docs]
def ifConstruct(self):
localctx = Fortran90Parser.IfConstructContext(self, self._ctx, self.state)
self.enterRule(localctx, 354, self.RULE_ifConstruct)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 2108
self.ifThenStmt()
self.state = 2109
self.conditionalBody()
self.state = 2113
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,155,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 2110
self.elseIfConstruct()
self.state = 2115
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,155,self._ctx)
self.state = 2117
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.ELSE:
self.state = 2116
self.elseConstruct()
self.state = 2119
self.endIfStmt()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class IfThenStmtContext(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(Fortran90Parser.IF, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def THEN(self):
return self.getToken(Fortran90Parser.THEN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_ifThenStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIfThenStmt" ):
listener.enterIfThenStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIfThenStmt" ):
listener.exitIfThenStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIfThenStmt" ):
return visitor.visitIfThenStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def ifThenStmt(self):
localctx = Fortran90Parser.IfThenStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 356, self.RULE_ifThenStmt)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2121
self.match(Fortran90Parser.IF)
self.state = 2122
self.match(Fortran90Parser.LPAREN)
self.state = 2123
self.expression(0)
self.state = 2124
self.match(Fortran90Parser.RPAREN)
self.state = 2125
self.match(Fortran90Parser.THEN)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ConditionalBodyContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def executionPartConstruct(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.ExecutionPartConstructContext)
else:
return self.getTypedRuleContext(Fortran90Parser.ExecutionPartConstructContext,i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_conditionalBody
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterConditionalBody" ):
listener.enterConditionalBody(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitConditionalBody" ):
listener.exitConditionalBody(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitConditionalBody" ):
return visitor.visitConditionalBody(self)
else:
return visitor.visitChildren(self)
[docs]
def conditionalBody(self):
localctx = Fortran90Parser.ConditionalBodyContext(self, self._ctx, self.state)
self.enterRule(localctx, 358, self.RULE_conditionalBody)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2130
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,157,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 2127
self.executionPartConstruct()
self.state = 2132
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,157,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 ElseIfConstructContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def elseIfStmt(self):
return self.getTypedRuleContext(Fortran90Parser.ElseIfStmtContext,0)
[docs]
def conditionalBody(self):
return self.getTypedRuleContext(Fortran90Parser.ConditionalBodyContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_elseIfConstruct
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterElseIfConstruct" ):
listener.enterElseIfConstruct(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitElseIfConstruct" ):
listener.exitElseIfConstruct(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitElseIfConstruct" ):
return visitor.visitElseIfConstruct(self)
else:
return visitor.visitChildren(self)
[docs]
def elseIfConstruct(self):
localctx = Fortran90Parser.ElseIfConstructContext(self, self._ctx, self.state)
self.enterRule(localctx, 360, self.RULE_elseIfConstruct)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2133
self.elseIfStmt()
self.state = 2134
self.conditionalBody()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ElseIfStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ELSEIF(self):
return self.getToken(Fortran90Parser.ELSEIF, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def THEN(self):
return self.getToken(Fortran90Parser.THEN, 0)
[docs]
def ELSE(self):
return self.getToken(Fortran90Parser.ELSE, 0)
[docs]
def IF(self):
return self.getToken(Fortran90Parser.IF, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_elseIfStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterElseIfStmt" ):
listener.enterElseIfStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitElseIfStmt" ):
listener.exitElseIfStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitElseIfStmt" ):
return visitor.visitElseIfStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def elseIfStmt(self):
localctx = Fortran90Parser.ElseIfStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 362, self.RULE_elseIfStmt)
try:
self.state = 2149
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.ELSEIF]:
self.enterOuterAlt(localctx, 1)
self.state = 2136
self.match(Fortran90Parser.ELSEIF)
self.state = 2137
self.match(Fortran90Parser.LPAREN)
self.state = 2138
self.expression(0)
self.state = 2139
self.match(Fortran90Parser.RPAREN)
self.state = 2140
self.match(Fortran90Parser.THEN)
pass
elif token in [Fortran90Parser.ELSE]:
self.enterOuterAlt(localctx, 2)
self.state = 2142
self.match(Fortran90Parser.ELSE)
self.state = 2143
self.match(Fortran90Parser.IF)
self.state = 2144
self.match(Fortran90Parser.LPAREN)
self.state = 2145
self.expression(0)
self.state = 2146
self.match(Fortran90Parser.RPAREN)
self.state = 2147
self.match(Fortran90Parser.THEN)
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 ElseConstructContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def elseStmt(self):
return self.getTypedRuleContext(Fortran90Parser.ElseStmtContext,0)
[docs]
def conditionalBody(self):
return self.getTypedRuleContext(Fortran90Parser.ConditionalBodyContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_elseConstruct
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterElseConstruct" ):
listener.enterElseConstruct(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitElseConstruct" ):
listener.exitElseConstruct(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitElseConstruct" ):
return visitor.visitElseConstruct(self)
else:
return visitor.visitChildren(self)
[docs]
def elseConstruct(self):
localctx = Fortran90Parser.ElseConstructContext(self, self._ctx, self.state)
self.enterRule(localctx, 364, self.RULE_elseConstruct)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2151
self.elseStmt()
self.state = 2152
self.conditionalBody()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ElseStmtContext(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(Fortran90Parser.ELSE, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_elseStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterElseStmt" ):
listener.enterElseStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitElseStmt" ):
listener.exitElseStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitElseStmt" ):
return visitor.visitElseStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def elseStmt(self):
localctx = Fortran90Parser.ElseStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 366, self.RULE_elseStmt)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2154
self.match(Fortran90Parser.ELSE)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class EndIfStmtContext(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(Fortran90Parser.ENDIF, 0)
[docs]
def END(self):
return self.getToken(Fortran90Parser.END, 0)
[docs]
def IF(self):
return self.getToken(Fortran90Parser.IF, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_endIfStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEndIfStmt" ):
listener.enterEndIfStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEndIfStmt" ):
listener.exitEndIfStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEndIfStmt" ):
return visitor.visitEndIfStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def endIfStmt(self):
localctx = Fortran90Parser.EndIfStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 368, self.RULE_endIfStmt)
try:
self.state = 2159
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.ENDIF]:
self.enterOuterAlt(localctx, 1)
self.state = 2156
self.match(Fortran90Parser.ENDIF)
pass
elif token in [Fortran90Parser.END]:
self.enterOuterAlt(localctx, 2)
self.state = 2157
self.match(Fortran90Parser.END)
self.state = 2158
self.match(Fortran90Parser.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 DoConstructContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def labelDoStmt(self):
return self.getTypedRuleContext(Fortran90Parser.LabelDoStmtContext,0)
[docs]
def blockDoConstruct(self):
return self.getTypedRuleContext(Fortran90Parser.BlockDoConstructContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_doConstruct
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDoConstruct" ):
listener.enterDoConstruct(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDoConstruct" ):
listener.exitDoConstruct(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDoConstruct" ):
return visitor.visitDoConstruct(self)
else:
return visitor.visitChildren(self)
[docs]
def doConstruct(self):
localctx = Fortran90Parser.DoConstructContext(self, self._ctx, self.state)
self.enterRule(localctx, 370, self.RULE_doConstruct)
try:
self.state = 2163
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,160,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2161
self.labelDoStmt()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2162
self.blockDoConstruct()
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 BlockDoConstructContext(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(Fortran90Parser.DO, 0)
[docs]
def endDoStmt(self):
return self.getTypedRuleContext(Fortran90Parser.EndDoStmtContext,0)
[docs]
def nameColon(self):
return self.getTypedRuleContext(Fortran90Parser.NameColonContext,0)
[docs]
def commaLoopControl(self):
return self.getTypedRuleContext(Fortran90Parser.CommaLoopControlContext,0)
[docs]
def executionPartConstruct(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.ExecutionPartConstructContext)
else:
return self.getTypedRuleContext(Fortran90Parser.ExecutionPartConstructContext,i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_blockDoConstruct
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterBlockDoConstruct" ):
listener.enterBlockDoConstruct(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitBlockDoConstruct" ):
listener.exitBlockDoConstruct(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitBlockDoConstruct" ):
return visitor.visitBlockDoConstruct(self)
else:
return visitor.visitChildren(self)
[docs]
def blockDoConstruct(self):
localctx = Fortran90Parser.BlockDoConstructContext(self, self._ctx, self.state)
self.enterRule(localctx, 372, self.RULE_blockDoConstruct)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 2166
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.NAME:
self.state = 2165
self.nameColon()
self.state = 2168
self.match(Fortran90Parser.DO)
self.state = 2170
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,162,self._ctx)
if la_ == 1:
self.state = 2169
self.commaLoopControl()
self.state = 2175
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,163,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 2172
self.executionPartConstruct()
self.state = 2177
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,163,self._ctx)
self.state = 2178
self.endDoStmt()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class EndDoStmtContext(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(Fortran90Parser.ENDDO, 0)
[docs]
def endName(self):
return self.getTypedRuleContext(Fortran90Parser.EndNameContext,0)
[docs]
def END(self):
return self.getToken(Fortran90Parser.END, 0)
[docs]
def DO(self):
return self.getToken(Fortran90Parser.DO, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_endDoStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEndDoStmt" ):
listener.enterEndDoStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEndDoStmt" ):
listener.exitEndDoStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEndDoStmt" ):
return visitor.visitEndDoStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def endDoStmt(self):
localctx = Fortran90Parser.EndDoStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 374, self.RULE_endDoStmt)
try:
self.state = 2189
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.ENDDO]:
self.enterOuterAlt(localctx, 1)
self.state = 2180
self.match(Fortran90Parser.ENDDO)
self.state = 2182
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,164,self._ctx)
if la_ == 1:
self.state = 2181
self.endName()
pass
elif token in [Fortran90Parser.END]:
self.enterOuterAlt(localctx, 2)
self.state = 2184
self.match(Fortran90Parser.END)
self.state = 2185
self.match(Fortran90Parser.DO)
self.state = 2187
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,165,self._ctx)
if la_ == 1:
self.state = 2186
self.endName()
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 EndNameContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ident(self):
return self.getTypedRuleContext(Fortran90Parser.IdentContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_endName
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEndName" ):
listener.enterEndName(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEndName" ):
listener.exitEndName(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEndName" ):
return visitor.visitEndName(self)
else:
return visitor.visitChildren(self)
[docs]
def endName(self):
localctx = Fortran90Parser.EndNameContext(self, self._ctx, self.state)
self.enterRule(localctx, 376, self.RULE_endName)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2191
self.ident()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class NameColonContext(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(Fortran90Parser.NAME, 0)
[docs]
def COLON(self):
return self.getToken(Fortran90Parser.COLON, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_nameColon
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterNameColon" ):
listener.enterNameColon(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitNameColon" ):
listener.exitNameColon(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNameColon" ):
return visitor.visitNameColon(self)
else:
return visitor.visitChildren(self)
[docs]
def nameColon(self):
localctx = Fortran90Parser.NameColonContext(self, self._ctx, self.state)
self.enterRule(localctx, 378, self.RULE_nameColon)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2193
self.match(Fortran90Parser.NAME)
self.state = 2194
self.match(Fortran90Parser.COLON)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class LabelDoStmtContext(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(Fortran90Parser.DO, 0)
[docs]
def doLblRef(self):
return self.getTypedRuleContext(Fortran90Parser.DoLblRefContext,0)
[docs]
def commaLoopControl(self):
return self.getTypedRuleContext(Fortran90Parser.CommaLoopControlContext,0)
[docs]
def doLblDef(self):
return self.getTypedRuleContext(Fortran90Parser.DoLblDefContext,0)
[docs]
def doLabelStmt(self):
return self.getTypedRuleContext(Fortran90Parser.DoLabelStmtContext,0)
[docs]
def executionPartConstruct(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.ExecutionPartConstructContext)
else:
return self.getTypedRuleContext(Fortran90Parser.ExecutionPartConstructContext,i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_labelDoStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLabelDoStmt" ):
listener.enterLabelDoStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLabelDoStmt" ):
listener.exitLabelDoStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLabelDoStmt" ):
return visitor.visitLabelDoStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def labelDoStmt(self):
localctx = Fortran90Parser.LabelDoStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 380, self.RULE_labelDoStmt)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2196
self.match(Fortran90Parser.DO)
self.state = 2197
self.doLblRef()
self.state = 2198
self.commaLoopControl()
self.state = 2202
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,167,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 2199
self.executionPartConstruct()
self.state = 2204
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,167,self._ctx)
self.state = 2205
self.doLblDef()
self.state = 2206
self.doLabelStmt()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class DoLblRefContext(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(Fortran90Parser.ICON, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_doLblRef
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDoLblRef" ):
listener.enterDoLblRef(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDoLblRef" ):
listener.exitDoLblRef(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDoLblRef" ):
return visitor.visitDoLblRef(self)
else:
return visitor.visitChildren(self)
[docs]
def doLblRef(self):
localctx = Fortran90Parser.DoLblRefContext(self, self._ctx, self.state)
self.enterRule(localctx, 382, self.RULE_doLblRef)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2208
self.match(Fortran90Parser.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 DoLblDefContext(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(Fortran90Parser.ICON, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_doLblDef
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDoLblDef" ):
listener.enterDoLblDef(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDoLblDef" ):
listener.exitDoLblDef(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDoLblDef" ):
return visitor.visitDoLblDef(self)
else:
return visitor.visitChildren(self)
[docs]
def doLblDef(self):
localctx = Fortran90Parser.DoLblDefContext(self, self._ctx, self.state)
self.enterRule(localctx, 384, self.RULE_doLblDef)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2210
self.match(Fortran90Parser.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 DoLabelStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def actionStmt(self):
return self.getTypedRuleContext(Fortran90Parser.ActionStmtContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_doLabelStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDoLabelStmt" ):
listener.enterDoLabelStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDoLabelStmt" ):
listener.exitDoLabelStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDoLabelStmt" ):
return visitor.visitDoLabelStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def doLabelStmt(self):
localctx = Fortran90Parser.DoLabelStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 386, self.RULE_doLabelStmt)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2212
self.actionStmt()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ExecutionPartConstructContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def executableConstruct(self):
return self.getTypedRuleContext(Fortran90Parser.ExecutableConstructContext,0)
[docs]
def formatStmt(self):
return self.getTypedRuleContext(Fortran90Parser.FormatStmtContext,0)
[docs]
def dataStmt(self):
return self.getTypedRuleContext(Fortran90Parser.DataStmtContext,0)
[docs]
def entryStmt(self):
return self.getTypedRuleContext(Fortran90Parser.EntryStmtContext,0)
[docs]
def doubleDoStmt(self):
return self.getTypedRuleContext(Fortran90Parser.DoubleDoStmtContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_executionPartConstruct
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterExecutionPartConstruct" ):
listener.enterExecutionPartConstruct(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitExecutionPartConstruct" ):
listener.exitExecutionPartConstruct(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitExecutionPartConstruct" ):
return visitor.visitExecutionPartConstruct(self)
else:
return visitor.visitChildren(self)
[docs]
def executionPartConstruct(self):
localctx = Fortran90Parser.ExecutionPartConstructContext(self, self._ctx, self.state)
self.enterRule(localctx, 388, self.RULE_executionPartConstruct)
try:
self.state = 2219
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,168,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2214
self.executableConstruct()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2215
self.formatStmt()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 2216
self.dataStmt()
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 2217
self.entryStmt()
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 2218
self.doubleDoStmt()
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 DoubleDoStmtContext(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(Fortran90Parser.DO, 0)
[docs]
def lblRef(self):
return self.getTypedRuleContext(Fortran90Parser.LblRefContext,0)
[docs]
def commaLoopControl(self):
return self.getTypedRuleContext(Fortran90Parser.CommaLoopControlContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_doubleDoStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDoubleDoStmt" ):
listener.enterDoubleDoStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDoubleDoStmt" ):
listener.exitDoubleDoStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDoubleDoStmt" ):
return visitor.visitDoubleDoStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def doubleDoStmt(self):
localctx = Fortran90Parser.DoubleDoStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 390, self.RULE_doubleDoStmt)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2221
self.match(Fortran90Parser.DO)
self.state = 2222
self.lblRef()
self.state = 2223
self.commaLoopControl()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class DataStmtContext(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(Fortran90Parser.DATA, 0)
[docs]
def dataStmtSet(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.DataStmtSetContext)
else:
return self.getTypedRuleContext(Fortran90Parser.DataStmtSetContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_dataStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDataStmt" ):
listener.enterDataStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDataStmt" ):
listener.exitDataStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDataStmt" ):
return visitor.visitDataStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def dataStmt(self):
localctx = Fortran90Parser.DataStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 392, self.RULE_dataStmt)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 2225
self.match(Fortran90Parser.DATA)
self.state = 2226
self.dataStmtSet()
self.state = 2233
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,170,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 2228
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.COMMA:
self.state = 2227
self.match(Fortran90Parser.COMMA)
self.state = 2230
self.dataStmtSet()
self.state = 2235
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,170,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 DataStmtSetContext(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(Fortran90Parser.Dse1Context,0)
[docs]
def dse2(self):
return self.getTypedRuleContext(Fortran90Parser.Dse2Context,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_dataStmtSet
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDataStmtSet" ):
listener.enterDataStmtSet(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDataStmtSet" ):
listener.exitDataStmtSet(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDataStmtSet" ):
return visitor.visitDataStmtSet(self)
else:
return visitor.visitChildren(self)
[docs]
def dataStmtSet(self):
localctx = Fortran90Parser.DataStmtSetContext(self, self._ctx, self.state)
self.enterRule(localctx, 394, self.RULE_dataStmtSet)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2236
self.dse1()
self.state = 2237
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 dataStmtObject(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.DataStmtObjectContext)
else:
return self.getTypedRuleContext(Fortran90Parser.DataStmtObjectContext,i)
[docs]
def DIV(self):
return self.getToken(Fortran90Parser.DIV, 0)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.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 = Fortran90Parser.Dse1Context(self, self._ctx, self.state)
self.enterRule(localctx, 396, self.RULE_dse1)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 2239
self.dataStmtObject()
self.state = 2244
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran90Parser.COMMA:
self.state = 2240
self.match(Fortran90Parser.COMMA)
self.state = 2241
self.dataStmtObject()
self.state = 2246
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 2247
self.match(Fortran90Parser.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 dataStmtValue(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.DataStmtValueContext)
else:
return self.getTypedRuleContext(Fortran90Parser.DataStmtValueContext,i)
[docs]
def DIV(self):
return self.getToken(Fortran90Parser.DIV, 0)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.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 = Fortran90Parser.Dse2Context(self, self._ctx, self.state)
self.enterRule(localctx, 398, self.RULE_dse2)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 2249
self.dataStmtValue()
self.state = 2254
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran90Parser.COMMA:
self.state = 2250
self.match(Fortran90Parser.COMMA)
self.state = 2251
self.dataStmtValue()
self.state = 2256
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 2257
self.match(Fortran90Parser.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 DataStmtValueContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def constant(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.ConstantContext)
else:
return self.getTypedRuleContext(Fortran90Parser.ConstantContext,i)
[docs]
def STAR(self):
return self.getToken(Fortran90Parser.STAR, 0)
[docs]
def namedConstantUse(self):
return self.getTypedRuleContext(Fortran90Parser.NamedConstantUseContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_dataStmtValue
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDataStmtValue" ):
listener.enterDataStmtValue(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDataStmtValue" ):
listener.exitDataStmtValue(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDataStmtValue" ):
return visitor.visitDataStmtValue(self)
else:
return visitor.visitChildren(self)
[docs]
def dataStmtValue(self):
localctx = Fortran90Parser.DataStmtValueContext(self, self._ctx, self.state)
self.enterRule(localctx, 400, self.RULE_dataStmtValue)
try:
self.state = 2268
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,173,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2259
self.constant()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2260
self.constant()
self.state = 2261
self.match(Fortran90Parser.STAR)
self.state = 2262
self.constant()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 2264
self.namedConstantUse()
self.state = 2265
self.match(Fortran90Parser.STAR)
self.state = 2266
self.constant()
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 DataStmtObjectContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def variable(self):
return self.getTypedRuleContext(Fortran90Parser.VariableContext,0)
[docs]
def dataImpliedDo(self):
return self.getTypedRuleContext(Fortran90Parser.DataImpliedDoContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_dataStmtObject
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDataStmtObject" ):
listener.enterDataStmtObject(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDataStmtObject" ):
listener.exitDataStmtObject(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDataStmtObject" ):
return visitor.visitDataStmtObject(self)
else:
return visitor.visitChildren(self)
[docs]
def dataStmtObject(self):
localctx = Fortran90Parser.DataStmtObjectContext(self, self._ctx, self.state)
self.enterRule(localctx, 402, self.RULE_dataStmtObject)
try:
self.state = 2272
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.NAME]:
self.enterOuterAlt(localctx, 1)
self.state = 2270
self.variable()
pass
elif token in [Fortran90Parser.LPAREN]:
self.enterOuterAlt(localctx, 2)
self.state = 2271
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 VariableContext(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(Fortran90Parser.VariableNameContext,0)
[docs]
def subscriptListRef(self):
return self.getTypedRuleContext(Fortran90Parser.SubscriptListRefContext,0)
[docs]
def substringRange(self):
return self.getTypedRuleContext(Fortran90Parser.SubstringRangeContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_variable
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterVariable" ):
listener.enterVariable(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitVariable" ):
listener.exitVariable(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitVariable" ):
return visitor.visitVariable(self)
else:
return visitor.visitChildren(self)
[docs]
def variable(self):
localctx = Fortran90Parser.VariableContext(self, self._ctx, self.state)
self.enterRule(localctx, 404, self.RULE_variable)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2274
self.variableName()
self.state = 2276
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,175,self._ctx)
if la_ == 1:
self.state = 2275
self.subscriptListRef()
self.state = 2279
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,176,self._ctx)
if la_ == 1:
self.state = 2278
self.substringRange()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class SubscriptListRefContext(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(Fortran90Parser.LPAREN, 0)
[docs]
def subscriptList(self):
return self.getTypedRuleContext(Fortran90Parser.SubscriptListContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_subscriptListRef
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSubscriptListRef" ):
listener.enterSubscriptListRef(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSubscriptListRef" ):
listener.exitSubscriptListRef(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSubscriptListRef" ):
return visitor.visitSubscriptListRef(self)
else:
return visitor.visitChildren(self)
[docs]
def subscriptListRef(self):
localctx = Fortran90Parser.SubscriptListRefContext(self, self._ctx, self.state)
self.enterRule(localctx, 406, self.RULE_subscriptListRef)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2281
self.match(Fortran90Parser.LPAREN)
self.state = 2282
self.subscriptList()
self.state = 2283
self.match(Fortran90Parser.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 SubscriptListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def subscript(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.SubscriptContext)
else:
return self.getTypedRuleContext(Fortran90Parser.SubscriptContext,i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_subscriptList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSubscriptList" ):
listener.enterSubscriptList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSubscriptList" ):
listener.exitSubscriptList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSubscriptList" ):
return visitor.visitSubscriptList(self)
else:
return visitor.visitChildren(self)
[docs]
def subscriptList(self):
localctx = Fortran90Parser.SubscriptListContext(self, self._ctx, self.state)
self.enterRule(localctx, 408, self.RULE_subscriptList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 2286
self._errHandler.sync(self)
_la = self._input.LA(1)
while True:
self.state = 2285
self.subscript()
self.state = 2288
self._errHandler.sync(self)
_la = self._input.LA(1)
if not (_la==Fortran90Parser.DOP or _la==Fortran90Parser.REAL or ((((_la - 84)) & ~0x3f) == 0 and ((1 << (_la - 84)) & ((1 << (Fortran90Parser.SIZE - 84)) | (1 << (Fortran90Parser.LPAREN - 84)) | (1 << (Fortran90Parser.MINUS - 84)) | (1 << (Fortran90Parser.PLUS - 84)) | (1 << (Fortran90Parser.LNOT - 84)))) != 0) or ((((_la - 149)) & ~0x3f) == 0 and ((1 << (_la - 149)) & ((1 << (Fortran90Parser.TRUE - 149)) | (1 << (Fortran90Parser.FALSE - 149)) | (1 << (Fortran90Parser.OBRACKETSLASH - 149)) | (1 << (Fortran90Parser.SCON - 149)) | (1 << (Fortran90Parser.RDCON - 149)) | (1 << (Fortran90Parser.ICON - 149)) | (1 << (Fortran90Parser.NAME - 149)))) != 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 SubscriptContext(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(Fortran90Parser.ExpressionContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_subscript
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSubscript" ):
listener.enterSubscript(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSubscript" ):
listener.exitSubscript(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSubscript" ):
return visitor.visitSubscript(self)
else:
return visitor.visitChildren(self)
[docs]
def subscript(self):
localctx = Fortran90Parser.SubscriptContext(self, self._ctx, self.state)
self.enterRule(localctx, 410, self.RULE_subscript)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2290
self.expression(0)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class SubstringRangeContext(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(Fortran90Parser.LPAREN, 0)
[docs]
def subscriptTripletTail(self):
return self.getTypedRuleContext(Fortran90Parser.SubscriptTripletTailContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_substringRange
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSubstringRange" ):
listener.enterSubstringRange(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSubstringRange" ):
listener.exitSubstringRange(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSubstringRange" ):
return visitor.visitSubstringRange(self)
else:
return visitor.visitChildren(self)
[docs]
def substringRange(self):
localctx = Fortran90Parser.SubstringRangeContext(self, self._ctx, self.state)
self.enterRule(localctx, 412, self.RULE_substringRange)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 2292
self.match(Fortran90Parser.LPAREN)
self.state = 2294
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.DOP or _la==Fortran90Parser.REAL or ((((_la - 84)) & ~0x3f) == 0 and ((1 << (_la - 84)) & ((1 << (Fortran90Parser.SIZE - 84)) | (1 << (Fortran90Parser.LPAREN - 84)) | (1 << (Fortran90Parser.MINUS - 84)) | (1 << (Fortran90Parser.PLUS - 84)) | (1 << (Fortran90Parser.LNOT - 84)))) != 0) or ((((_la - 149)) & ~0x3f) == 0 and ((1 << (_la - 149)) & ((1 << (Fortran90Parser.TRUE - 149)) | (1 << (Fortran90Parser.FALSE - 149)) | (1 << (Fortran90Parser.OBRACKETSLASH - 149)) | (1 << (Fortran90Parser.SCON - 149)) | (1 << (Fortran90Parser.RDCON - 149)) | (1 << (Fortran90Parser.ICON - 149)) | (1 << (Fortran90Parser.NAME - 149)))) != 0):
self.state = 2293
self.expression(0)
self.state = 2296
self.subscriptTripletTail()
self.state = 2297
self.match(Fortran90Parser.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 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(Fortran90Parser.LPAREN, 0)
[docs]
def dataIDoObjectList(self):
return self.getTypedRuleContext(Fortran90Parser.DataIDoObjectListContext,0)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def impliedDoVariable(self):
return self.getTypedRuleContext(Fortran90Parser.ImpliedDoVariableContext,0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran90Parser.ASSIGN, 0)
[docs]
def expression(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.ExpressionContext)
else:
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,i)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.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 = Fortran90Parser.DataImpliedDoContext(self, self._ctx, self.state)
self.enterRule(localctx, 414, self.RULE_dataImpliedDo)
try:
self.state = 2321
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,179,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2299
self.match(Fortran90Parser.LPAREN)
self.state = 2300
self.dataIDoObjectList()
self.state = 2301
self.match(Fortran90Parser.COMMA)
self.state = 2302
self.impliedDoVariable()
self.state = 2303
self.match(Fortran90Parser.ASSIGN)
self.state = 2304
self.expression(0)
self.state = 2305
self.match(Fortran90Parser.COMMA)
self.state = 2306
self.expression(0)
self.state = 2307
self.match(Fortran90Parser.RPAREN)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2309
self.match(Fortran90Parser.LPAREN)
self.state = 2310
self.dataIDoObjectList()
self.state = 2311
self.match(Fortran90Parser.COMMA)
self.state = 2312
self.impliedDoVariable()
self.state = 2313
self.match(Fortran90Parser.ASSIGN)
self.state = 2314
self.expression(0)
self.state = 2315
self.match(Fortran90Parser.COMMA)
self.state = 2316
self.expression(0)
self.state = 2317
self.match(Fortran90Parser.COMMA)
self.state = 2318
self.expression(0)
self.state = 2319
self.match(Fortran90Parser.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 DataIDoObjectListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def dataIDoObject(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.DataIDoObjectContext)
else:
return self.getTypedRuleContext(Fortran90Parser.DataIDoObjectContext,i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_dataIDoObjectList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDataIDoObjectList" ):
listener.enterDataIDoObjectList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDataIDoObjectList" ):
listener.exitDataIDoObjectList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDataIDoObjectList" ):
return visitor.visitDataIDoObjectList(self)
else:
return visitor.visitChildren(self)
[docs]
def dataIDoObjectList(self):
localctx = Fortran90Parser.DataIDoObjectListContext(self, self._ctx, self.state)
self.enterRule(localctx, 416, self.RULE_dataIDoObjectList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 2324
self._errHandler.sync(self)
_la = self._input.LA(1)
while True:
self.state = 2323
self.dataIDoObject()
self.state = 2326
self._errHandler.sync(self)
_la = self._input.LA(1)
if not (_la==Fortran90Parser.LPAREN or _la==Fortran90Parser.NAME):
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 DataIDoObjectContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def arrayElement(self):
return self.getTypedRuleContext(Fortran90Parser.ArrayElementContext,0)
[docs]
def dataImpliedDo(self):
return self.getTypedRuleContext(Fortran90Parser.DataImpliedDoContext,0)
[docs]
def structureComponent(self):
return self.getTypedRuleContext(Fortran90Parser.StructureComponentContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_dataIDoObject
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDataIDoObject" ):
listener.enterDataIDoObject(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDataIDoObject" ):
listener.exitDataIDoObject(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDataIDoObject" ):
return visitor.visitDataIDoObject(self)
else:
return visitor.visitChildren(self)
[docs]
def dataIDoObject(self):
localctx = Fortran90Parser.DataIDoObjectContext(self, self._ctx, self.state)
self.enterRule(localctx, 418, self.RULE_dataIDoObject)
try:
self.state = 2331
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,181,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2328
self.arrayElement()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2329
self.dataImpliedDo()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 2330
self.structureComponent(0)
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 StructureComponentContext(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(Fortran90Parser.VariableNameContext,0)
[docs]
def fieldSelector(self):
return self.getTypedRuleContext(Fortran90Parser.FieldSelectorContext,0)
[docs]
def structureComponent(self):
return self.getTypedRuleContext(Fortran90Parser.StructureComponentContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_structureComponent
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterStructureComponent" ):
listener.enterStructureComponent(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitStructureComponent" ):
listener.exitStructureComponent(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitStructureComponent" ):
return visitor.visitStructureComponent(self)
else:
return visitor.visitChildren(self)
[docs]
def structureComponent(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = Fortran90Parser.StructureComponentContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 420
self.enterRecursionRule(localctx, 420, self.RULE_structureComponent, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2334
self.variableName()
self.state = 2335
self.fieldSelector()
self._ctx.stop = self._input.LT(-1)
self.state = 2341
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,182,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = Fortran90Parser.StructureComponentContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_structureComponent)
self.state = 2337
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 2338
self.fieldSelector()
self.state = 2343
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,182,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class FieldSelectorContext(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(Fortran90Parser.LPAREN, 0)
[docs]
def sectionSubscriptList(self):
return self.getTypedRuleContext(Fortran90Parser.SectionSubscriptListContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def PCT(self):
return self.getToken(Fortran90Parser.PCT, 0)
[docs]
def NAME(self):
return self.getToken(Fortran90Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_fieldSelector
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterFieldSelector" ):
listener.enterFieldSelector(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitFieldSelector" ):
listener.exitFieldSelector(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFieldSelector" ):
return visitor.visitFieldSelector(self)
else:
return visitor.visitChildren(self)
[docs]
def fieldSelector(self):
localctx = Fortran90Parser.FieldSelectorContext(self, self._ctx, self.state)
self.enterRule(localctx, 422, self.RULE_fieldSelector)
try:
self.state = 2352
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.LPAREN]:
self.enterOuterAlt(localctx, 1)
self.state = 2344
self.match(Fortran90Parser.LPAREN)
self.state = 2345
self.sectionSubscriptList()
self.state = 2346
self.match(Fortran90Parser.RPAREN)
self.state = 2347
self.match(Fortran90Parser.PCT)
self.state = 2348
self.match(Fortran90Parser.NAME)
pass
elif token in [Fortran90Parser.PCT]:
self.enterOuterAlt(localctx, 2)
self.state = 2350
self.match(Fortran90Parser.PCT)
self.state = 2351
self.match(Fortran90Parser.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 ArrayElementContext(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(Fortran90Parser.VariableNameContext,0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def sectionSubscriptList(self):
return self.getTypedRuleContext(Fortran90Parser.SectionSubscriptListContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def structureComponent(self):
return self.getTypedRuleContext(Fortran90Parser.StructureComponentContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_arrayElement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterArrayElement" ):
listener.enterArrayElement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitArrayElement" ):
listener.exitArrayElement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitArrayElement" ):
return visitor.visitArrayElement(self)
else:
return visitor.visitChildren(self)
[docs]
def arrayElement(self):
localctx = Fortran90Parser.ArrayElementContext(self, self._ctx, self.state)
self.enterRule(localctx, 424, self.RULE_arrayElement)
try:
self.state = 2364
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,184,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2354
self.variableName()
self.state = 2355
self.match(Fortran90Parser.LPAREN)
self.state = 2356
self.sectionSubscriptList()
self.state = 2357
self.match(Fortran90Parser.RPAREN)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2359
self.structureComponent(0)
self.state = 2360
self.match(Fortran90Parser.LPAREN)
self.state = 2361
self.sectionSubscriptList()
self.state = 2362
self.match(Fortran90Parser.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 ImpliedDoVariableContext(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(Fortran90Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_impliedDoVariable
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterImpliedDoVariable" ):
listener.enterImpliedDoVariable(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitImpliedDoVariable" ):
listener.exitImpliedDoVariable(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitImpliedDoVariable" ):
return visitor.visitImpliedDoVariable(self)
else:
return visitor.visitChildren(self)
[docs]
def impliedDoVariable(self):
localctx = Fortran90Parser.ImpliedDoVariableContext(self, self._ctx, self.state)
self.enterRule(localctx, 426, self.RULE_impliedDoVariable)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2366
self.match(Fortran90Parser.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 CommaLoopControlContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def loopControl(self):
return self.getTypedRuleContext(Fortran90Parser.LoopControlContext,0)
[docs]
def COMMA(self):
return self.getToken(Fortran90Parser.COMMA, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_commaLoopControl
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCommaLoopControl" ):
listener.enterCommaLoopControl(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCommaLoopControl" ):
listener.exitCommaLoopControl(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCommaLoopControl" ):
return visitor.visitCommaLoopControl(self)
else:
return visitor.visitChildren(self)
[docs]
def commaLoopControl(self):
localctx = Fortran90Parser.CommaLoopControlContext(self, self._ctx, self.state)
self.enterRule(localctx, 428, self.RULE_commaLoopControl)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 2369
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.COMMA:
self.state = 2368
self.match(Fortran90Parser.COMMA)
self.state = 2371
self.loopControl()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class LoopControlContext(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(Fortran90Parser.VariableNameContext,0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran90Parser.ASSIGN, 0)
[docs]
def expression(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.ExpressionContext)
else:
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,i)
[docs]
def COMMA(self):
return self.getToken(Fortran90Parser.COMMA, 0)
[docs]
def commaExpr(self):
return self.getTypedRuleContext(Fortran90Parser.CommaExprContext,0)
[docs]
def WHILE(self):
return self.getToken(Fortran90Parser.WHILE, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_loopControl
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLoopControl" ):
listener.enterLoopControl(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLoopControl" ):
listener.exitLoopControl(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLoopControl" ):
return visitor.visitLoopControl(self)
else:
return visitor.visitChildren(self)
[docs]
def loopControl(self):
localctx = Fortran90Parser.LoopControlContext(self, self._ctx, self.state)
self.enterRule(localctx, 430, self.RULE_loopControl)
try:
self.state = 2386
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.NAME]:
self.enterOuterAlt(localctx, 1)
self.state = 2373
self.variableName()
self.state = 2374
self.match(Fortran90Parser.ASSIGN)
self.state = 2375
self.expression(0)
self.state = 2376
self.match(Fortran90Parser.COMMA)
self.state = 2377
self.expression(0)
self.state = 2379
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,186,self._ctx)
if la_ == 1:
self.state = 2378
self.commaExpr()
pass
elif token in [Fortran90Parser.WHILE]:
self.enterOuterAlt(localctx, 2)
self.state = 2381
self.match(Fortran90Parser.WHILE)
self.state = 2382
self.match(Fortran90Parser.LPAREN)
self.state = 2383
self.expression(0)
self.state = 2384
self.match(Fortran90Parser.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 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(Fortran90Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.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 = Fortran90Parser.VariableNameContext(self, self._ctx, self.state)
self.enterRule(localctx, 432, self.RULE_variableName)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2388
self.match(Fortran90Parser.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 CommaExprContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def COMMA(self):
return self.getToken(Fortran90Parser.COMMA, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_commaExpr
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCommaExpr" ):
listener.enterCommaExpr(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCommaExpr" ):
listener.exitCommaExpr(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCommaExpr" ):
return visitor.visitCommaExpr(self)
else:
return visitor.visitChildren(self)
[docs]
def commaExpr(self):
localctx = Fortran90Parser.CommaExprContext(self, self._ctx, self.state)
self.enterRule(localctx, 434, self.RULE_commaExpr)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2390
self.match(Fortran90Parser.COMMA)
self.state = 2391
self.expression(0)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ActionStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def arithmeticIfStmt(self):
return self.getTypedRuleContext(Fortran90Parser.ArithmeticIfStmtContext,0)
[docs]
def assignmentStmt(self):
return self.getTypedRuleContext(Fortran90Parser.AssignmentStmtContext,0)
[docs]
def assignStmt(self):
return self.getTypedRuleContext(Fortran90Parser.AssignStmtContext,0)
[docs]
def backspaceStmt(self):
return self.getTypedRuleContext(Fortran90Parser.BackspaceStmtContext,0)
[docs]
def callStmt(self):
return self.getTypedRuleContext(Fortran90Parser.CallStmtContext,0)
[docs]
def closeStmt(self):
return self.getTypedRuleContext(Fortran90Parser.CloseStmtContext,0)
[docs]
def continueStmt(self):
return self.getTypedRuleContext(Fortran90Parser.ContinueStmtContext,0)
[docs]
def endfileStmt(self):
return self.getTypedRuleContext(Fortran90Parser.EndfileStmtContext,0)
[docs]
def gotoStmt(self):
return self.getTypedRuleContext(Fortran90Parser.GotoStmtContext,0)
[docs]
def computedGotoStmt(self):
return self.getTypedRuleContext(Fortran90Parser.ComputedGotoStmtContext,0)
[docs]
def assignedGotoStmt(self):
return self.getTypedRuleContext(Fortran90Parser.AssignedGotoStmtContext,0)
[docs]
def ifStmt(self):
return self.getTypedRuleContext(Fortran90Parser.IfStmtContext,0)
[docs]
def inquireStmt(self):
return self.getTypedRuleContext(Fortran90Parser.InquireStmtContext,0)
[docs]
def openStmt(self):
return self.getTypedRuleContext(Fortran90Parser.OpenStmtContext,0)
[docs]
def pauseStmt(self):
return self.getTypedRuleContext(Fortran90Parser.PauseStmtContext,0)
[docs]
def printStmt(self):
return self.getTypedRuleContext(Fortran90Parser.PrintStmtContext,0)
[docs]
def readStmt(self):
return self.getTypedRuleContext(Fortran90Parser.ReadStmtContext,0)
[docs]
def returnStmt(self):
return self.getTypedRuleContext(Fortran90Parser.ReturnStmtContext,0)
[docs]
def rewindStmt(self):
return self.getTypedRuleContext(Fortran90Parser.RewindStmtContext,0)
[docs]
def stmtFunctionStmt(self):
return self.getTypedRuleContext(Fortran90Parser.StmtFunctionStmtContext,0)
[docs]
def stopStmt(self):
return self.getTypedRuleContext(Fortran90Parser.StopStmtContext,0)
[docs]
def writeStmt(self):
return self.getTypedRuleContext(Fortran90Parser.WriteStmtContext,0)
[docs]
def allocateStmt(self):
return self.getTypedRuleContext(Fortran90Parser.AllocateStmtContext,0)
[docs]
def cycleStmt(self):
return self.getTypedRuleContext(Fortran90Parser.CycleStmtContext,0)
[docs]
def deallocateStmt(self):
return self.getTypedRuleContext(Fortran90Parser.DeallocateStmtContext,0)
[docs]
def exitStmt(self):
return self.getTypedRuleContext(Fortran90Parser.ExitStmtContext,0)
[docs]
def nullifyStmt(self):
return self.getTypedRuleContext(Fortran90Parser.NullifyStmtContext,0)
[docs]
def pointerAssignmentStmt(self):
return self.getTypedRuleContext(Fortran90Parser.PointerAssignmentStmtContext,0)
[docs]
def whereStmt(self):
return self.getTypedRuleContext(Fortran90Parser.WhereStmtContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_actionStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterActionStmt" ):
listener.enterActionStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitActionStmt" ):
listener.exitActionStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitActionStmt" ):
return visitor.visitActionStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def actionStmt(self):
localctx = Fortran90Parser.ActionStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 436, self.RULE_actionStmt)
try:
self.state = 2422
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,188,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2393
self.arithmeticIfStmt()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2394
self.assignmentStmt()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 2395
self.assignStmt()
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 2396
self.backspaceStmt()
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 2397
self.callStmt()
pass
elif la_ == 6:
self.enterOuterAlt(localctx, 6)
self.state = 2398
self.closeStmt()
pass
elif la_ == 7:
self.enterOuterAlt(localctx, 7)
self.state = 2399
self.continueStmt()
pass
elif la_ == 8:
self.enterOuterAlt(localctx, 8)
self.state = 2400
self.endfileStmt()
pass
elif la_ == 9:
self.enterOuterAlt(localctx, 9)
self.state = 2401
self.gotoStmt()
pass
elif la_ == 10:
self.enterOuterAlt(localctx, 10)
self.state = 2402
self.computedGotoStmt()
pass
elif la_ == 11:
self.enterOuterAlt(localctx, 11)
self.state = 2403
self.assignedGotoStmt()
pass
elif la_ == 12:
self.enterOuterAlt(localctx, 12)
self.state = 2404
self.ifStmt()
pass
elif la_ == 13:
self.enterOuterAlt(localctx, 13)
self.state = 2405
self.inquireStmt()
pass
elif la_ == 14:
self.enterOuterAlt(localctx, 14)
self.state = 2406
self.openStmt()
pass
elif la_ == 15:
self.enterOuterAlt(localctx, 15)
self.state = 2407
self.pauseStmt()
pass
elif la_ == 16:
self.enterOuterAlt(localctx, 16)
self.state = 2408
self.printStmt()
pass
elif la_ == 17:
self.enterOuterAlt(localctx, 17)
self.state = 2409
self.readStmt()
pass
elif la_ == 18:
self.enterOuterAlt(localctx, 18)
self.state = 2410
self.returnStmt()
pass
elif la_ == 19:
self.enterOuterAlt(localctx, 19)
self.state = 2411
self.rewindStmt()
pass
elif la_ == 20:
self.enterOuterAlt(localctx, 20)
self.state = 2412
self.stmtFunctionStmt()
pass
elif la_ == 21:
self.enterOuterAlt(localctx, 21)
self.state = 2413
self.stopStmt()
pass
elif la_ == 22:
self.enterOuterAlt(localctx, 22)
self.state = 2414
self.writeStmt()
pass
elif la_ == 23:
self.enterOuterAlt(localctx, 23)
self.state = 2415
self.allocateStmt()
pass
elif la_ == 24:
self.enterOuterAlt(localctx, 24)
self.state = 2416
self.cycleStmt()
pass
elif la_ == 25:
self.enterOuterAlt(localctx, 25)
self.state = 2417
self.deallocateStmt()
pass
elif la_ == 26:
self.enterOuterAlt(localctx, 26)
self.state = 2418
self.exitStmt()
pass
elif la_ == 27:
self.enterOuterAlt(localctx, 27)
self.state = 2419
self.nullifyStmt()
pass
elif la_ == 28:
self.enterOuterAlt(localctx, 28)
self.state = 2420
self.pointerAssignmentStmt()
pass
elif la_ == 29:
self.enterOuterAlt(localctx, 29)
self.state = 2421
self.whereStmt()
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 WhereStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def WHERE(self):
return self.getToken(Fortran90Parser.WHERE, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def maskExpr(self):
return self.getTypedRuleContext(Fortran90Parser.MaskExprContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def assignmentStmt(self):
return self.getTypedRuleContext(Fortran90Parser.AssignmentStmtContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_whereStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterWhereStmt" ):
listener.enterWhereStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitWhereStmt" ):
listener.exitWhereStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitWhereStmt" ):
return visitor.visitWhereStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def whereStmt(self):
localctx = Fortran90Parser.WhereStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 438, self.RULE_whereStmt)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2424
self.match(Fortran90Parser.WHERE)
self.state = 2425
self.match(Fortran90Parser.LPAREN)
self.state = 2426
self.maskExpr()
self.state = 2427
self.match(Fortran90Parser.RPAREN)
self.state = 2428
self.assignmentStmt()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class PointerAssignmentStmtContext(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(Fortran90Parser.NAME, 0)
[docs]
def IMPLIEDT(self):
return self.getToken(Fortran90Parser.IMPLIEDT, 0)
[docs]
def target(self):
return self.getTypedRuleContext(Fortran90Parser.TargetContext,0)
[docs]
def PCT(self):
return self.getToken(Fortran90Parser.PCT, 0)
[docs]
def nameDataRef(self):
return self.getTypedRuleContext(Fortran90Parser.NameDataRefContext,0)
[docs]
def sFExprListRef(self):
return self.getTypedRuleContext(Fortran90Parser.SFExprListRefContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_pointerAssignmentStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPointerAssignmentStmt" ):
listener.enterPointerAssignmentStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPointerAssignmentStmt" ):
listener.exitPointerAssignmentStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPointerAssignmentStmt" ):
return visitor.visitPointerAssignmentStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def pointerAssignmentStmt(self):
localctx = Fortran90Parser.PointerAssignmentStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 440, self.RULE_pointerAssignmentStmt)
self._la = 0 # Token type
try:
self.state = 2442
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,190,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2430
self.match(Fortran90Parser.NAME)
self.state = 2431
self.match(Fortran90Parser.IMPLIEDT)
self.state = 2432
self.target()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2433
self.match(Fortran90Parser.NAME)
self.state = 2435
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.LPAREN:
self.state = 2434
self.sFExprListRef()
self.state = 2437
self.match(Fortran90Parser.PCT)
self.state = 2438
self.nameDataRef()
self.state = 2439
self.match(Fortran90Parser.IMPLIEDT)
self.state = 2440
self.target()
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 TargetContext(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(Fortran90Parser.ExpressionContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_target
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTarget" ):
listener.enterTarget(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTarget" ):
listener.exitTarget(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTarget" ):
return visitor.visitTarget(self)
else:
return visitor.visitChildren(self)
[docs]
def target(self):
localctx = Fortran90Parser.TargetContext(self, self._ctx, self.state)
self.enterRule(localctx, 442, self.RULE_target)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2444
self.expression(0)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class NullifyStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def NULLIFY(self):
return self.getToken(Fortran90Parser.NULLIFY, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def pointerObjectList(self):
return self.getTypedRuleContext(Fortran90Parser.PointerObjectListContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_nullifyStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterNullifyStmt" ):
listener.enterNullifyStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitNullifyStmt" ):
listener.exitNullifyStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNullifyStmt" ):
return visitor.visitNullifyStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def nullifyStmt(self):
localctx = Fortran90Parser.NullifyStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 444, self.RULE_nullifyStmt)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2446
self.match(Fortran90Parser.NULLIFY)
self.state = 2447
self.match(Fortran90Parser.LPAREN)
self.state = 2448
self.pointerObjectList()
self.state = 2449
self.match(Fortran90Parser.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 PointerObjectListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def pointerObject(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.PointerObjectContext)
else:
return self.getTypedRuleContext(Fortran90Parser.PointerObjectContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_pointerObjectList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPointerObjectList" ):
listener.enterPointerObjectList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPointerObjectList" ):
listener.exitPointerObjectList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPointerObjectList" ):
return visitor.visitPointerObjectList(self)
else:
return visitor.visitChildren(self)
[docs]
def pointerObjectList(self):
localctx = Fortran90Parser.PointerObjectListContext(self, self._ctx, self.state)
self.enterRule(localctx, 446, self.RULE_pointerObjectList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 2451
self.pointerObject()
self.state = 2456
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran90Parser.COMMA:
self.state = 2452
self.match(Fortran90Parser.COMMA)
self.state = 2453
self.pointerObject()
self.state = 2458
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 PointerObjectContext(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(Fortran90Parser.NAME, 0)
[docs]
def pointerField(self):
return self.getTypedRuleContext(Fortran90Parser.PointerFieldContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_pointerObject
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPointerObject" ):
listener.enterPointerObject(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPointerObject" ):
listener.exitPointerObject(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPointerObject" ):
return visitor.visitPointerObject(self)
else:
return visitor.visitChildren(self)
[docs]
def pointerObject(self):
localctx = Fortran90Parser.PointerObjectContext(self, self._ctx, self.state)
self.enterRule(localctx, 448, self.RULE_pointerObject)
try:
self.state = 2461
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,192,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2459
self.match(Fortran90Parser.NAME)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2460
self.pointerField(0)
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 PointerFieldContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def NAME(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.NAME)
else:
return self.getToken(Fortran90Parser.NAME, i)
[docs]
def PCT(self):
return self.getToken(Fortran90Parser.PCT, 0)
[docs]
def sFExprListRef(self):
return self.getTypedRuleContext(Fortran90Parser.SFExprListRefContext,0)
[docs]
def pointerField(self):
return self.getTypedRuleContext(Fortran90Parser.PointerFieldContext,0)
[docs]
def fieldSelector(self):
return self.getTypedRuleContext(Fortran90Parser.FieldSelectorContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_pointerField
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPointerField" ):
listener.enterPointerField(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPointerField" ):
listener.exitPointerField(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPointerField" ):
return visitor.visitPointerField(self)
else:
return visitor.visitChildren(self)
[docs]
def pointerField(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = Fortran90Parser.PointerFieldContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 450
self.enterRecursionRule(localctx, 450, self.RULE_pointerField, _p)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 2464
self.match(Fortran90Parser.NAME)
self.state = 2466
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.LPAREN:
self.state = 2465
self.sFExprListRef()
self.state = 2468
self.match(Fortran90Parser.PCT)
self.state = 2469
self.match(Fortran90Parser.NAME)
self._ctx.stop = self._input.LT(-1)
self.state = 2475
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,194,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = Fortran90Parser.PointerFieldContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_pointerField)
self.state = 2471
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 2472
self.fieldSelector()
self.state = 2477
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,194,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class ExitStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def EXIT(self):
return self.getToken(Fortran90Parser.EXIT, 0)
[docs]
def endName(self):
return self.getTypedRuleContext(Fortran90Parser.EndNameContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_exitStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterExitStmt" ):
listener.enterExitStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitExitStmt" ):
listener.exitExitStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitExitStmt" ):
return visitor.visitExitStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def exitStmt(self):
localctx = Fortran90Parser.ExitStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 452, self.RULE_exitStmt)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2478
self.match(Fortran90Parser.EXIT)
self.state = 2480
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,195,self._ctx)
if la_ == 1:
self.state = 2479
self.endName()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class DeallocateStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def DEALLOCATE(self):
return self.getToken(Fortran90Parser.DEALLOCATE, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def allocateObjectList(self):
return self.getTypedRuleContext(Fortran90Parser.AllocateObjectListContext,0)
[docs]
def COMMA(self):
return self.getToken(Fortran90Parser.COMMA, 0)
[docs]
def STAT(self):
return self.getToken(Fortran90Parser.STAT, 0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran90Parser.ASSIGN, 0)
[docs]
def variable(self):
return self.getTypedRuleContext(Fortran90Parser.VariableContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_deallocateStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDeallocateStmt" ):
listener.enterDeallocateStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDeallocateStmt" ):
listener.exitDeallocateStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDeallocateStmt" ):
return visitor.visitDeallocateStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def deallocateStmt(self):
localctx = Fortran90Parser.DeallocateStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 454, self.RULE_deallocateStmt)
try:
self.state = 2496
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,196,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2482
self.match(Fortran90Parser.DEALLOCATE)
self.state = 2483
self.match(Fortran90Parser.LPAREN)
self.state = 2484
self.allocateObjectList()
self.state = 2485
self.match(Fortran90Parser.COMMA)
self.state = 2486
self.match(Fortran90Parser.STAT)
self.state = 2487
self.match(Fortran90Parser.ASSIGN)
self.state = 2488
self.variable()
self.state = 2489
self.match(Fortran90Parser.RPAREN)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2491
self.match(Fortran90Parser.DEALLOCATE)
self.state = 2492
self.match(Fortran90Parser.LPAREN)
self.state = 2493
self.allocateObjectList()
self.state = 2494
self.match(Fortran90Parser.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 AllocateObjectListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def allocateObject(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.AllocateObjectContext)
else:
return self.getTypedRuleContext(Fortran90Parser.AllocateObjectContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_allocateObjectList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAllocateObjectList" ):
listener.enterAllocateObjectList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAllocateObjectList" ):
listener.exitAllocateObjectList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAllocateObjectList" ):
return visitor.visitAllocateObjectList(self)
else:
return visitor.visitChildren(self)
[docs]
def allocateObjectList(self):
localctx = Fortran90Parser.AllocateObjectListContext(self, self._ctx, self.state)
self.enterRule(localctx, 456, self.RULE_allocateObjectList)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2498
self.allocateObject(0)
self.state = 2503
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,197,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 2499
self.match(Fortran90Parser.COMMA)
self.state = 2500
self.allocateObject(0)
self.state = 2505
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,197,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 CycleStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def CYCLE(self):
return self.getToken(Fortran90Parser.CYCLE, 0)
[docs]
def endName(self):
return self.getTypedRuleContext(Fortran90Parser.EndNameContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_cycleStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCycleStmt" ):
listener.enterCycleStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCycleStmt" ):
listener.exitCycleStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCycleStmt" ):
return visitor.visitCycleStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def cycleStmt(self):
localctx = Fortran90Parser.CycleStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 458, self.RULE_cycleStmt)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2506
self.match(Fortran90Parser.CYCLE)
self.state = 2508
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,198,self._ctx)
if la_ == 1:
self.state = 2507
self.endName()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class AllocateStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ALLOCATE(self):
return self.getToken(Fortran90Parser.ALLOCATE, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def allocationList(self):
return self.getTypedRuleContext(Fortran90Parser.AllocationListContext,0)
[docs]
def COMMA(self):
return self.getToken(Fortran90Parser.COMMA, 0)
[docs]
def STAT(self):
return self.getToken(Fortran90Parser.STAT, 0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran90Parser.ASSIGN, 0)
[docs]
def variable(self):
return self.getTypedRuleContext(Fortran90Parser.VariableContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_allocateStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAllocateStmt" ):
listener.enterAllocateStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAllocateStmt" ):
listener.exitAllocateStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAllocateStmt" ):
return visitor.visitAllocateStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def allocateStmt(self):
localctx = Fortran90Parser.AllocateStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 460, self.RULE_allocateStmt)
try:
self.state = 2524
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,199,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2510
self.match(Fortran90Parser.ALLOCATE)
self.state = 2511
self.match(Fortran90Parser.LPAREN)
self.state = 2512
self.allocationList()
self.state = 2513
self.match(Fortran90Parser.COMMA)
self.state = 2514
self.match(Fortran90Parser.STAT)
self.state = 2515
self.match(Fortran90Parser.ASSIGN)
self.state = 2516
self.variable()
self.state = 2517
self.match(Fortran90Parser.RPAREN)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2519
self.match(Fortran90Parser.ALLOCATE)
self.state = 2520
self.match(Fortran90Parser.LPAREN)
self.state = 2521
self.allocationList()
self.state = 2522
self.match(Fortran90Parser.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 AllocationListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def allocation(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.AllocationContext)
else:
return self.getTypedRuleContext(Fortran90Parser.AllocationContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_allocationList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAllocationList" ):
listener.enterAllocationList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAllocationList" ):
listener.exitAllocationList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAllocationList" ):
return visitor.visitAllocationList(self)
else:
return visitor.visitChildren(self)
[docs]
def allocationList(self):
localctx = Fortran90Parser.AllocationListContext(self, self._ctx, self.state)
self.enterRule(localctx, 462, self.RULE_allocationList)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2526
self.allocation()
self.state = 2531
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,200,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 2527
self.match(Fortran90Parser.COMMA)
self.state = 2528
self.allocation()
self.state = 2533
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,200,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 AllocationContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def allocateObject(self):
return self.getTypedRuleContext(Fortran90Parser.AllocateObjectContext,0)
[docs]
def allocatedShape(self):
return self.getTypedRuleContext(Fortran90Parser.AllocatedShapeContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_allocation
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAllocation" ):
listener.enterAllocation(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAllocation" ):
listener.exitAllocation(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAllocation" ):
return visitor.visitAllocation(self)
else:
return visitor.visitChildren(self)
[docs]
def allocation(self):
localctx = Fortran90Parser.AllocationContext(self, self._ctx, self.state)
self.enterRule(localctx, 464, self.RULE_allocation)
try:
self.state = 2538
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,201,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2534
self.allocateObject(0)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2535
self.allocateObject(0)
self.state = 2536
self.allocatedShape()
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 AllocateObjectContext(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(Fortran90Parser.VariableNameContext,0)
[docs]
def allocateObject(self):
return self.getTypedRuleContext(Fortran90Parser.AllocateObjectContext,0)
[docs]
def fieldSelector(self):
return self.getTypedRuleContext(Fortran90Parser.FieldSelectorContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_allocateObject
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAllocateObject" ):
listener.enterAllocateObject(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAllocateObject" ):
listener.exitAllocateObject(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAllocateObject" ):
return visitor.visitAllocateObject(self)
else:
return visitor.visitChildren(self)
[docs]
def allocateObject(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = Fortran90Parser.AllocateObjectContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 466
self.enterRecursionRule(localctx, 466, self.RULE_allocateObject, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2541
self.variableName()
self._ctx.stop = self._input.LT(-1)
self.state = 2547
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,202,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = Fortran90Parser.AllocateObjectContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_allocateObject)
self.state = 2543
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 2544
self.fieldSelector()
self.state = 2549
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,202,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class AllocatedShapeContext(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(Fortran90Parser.LPAREN, 0)
[docs]
def sectionSubscriptList(self):
return self.getTypedRuleContext(Fortran90Parser.SectionSubscriptListContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_allocatedShape
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAllocatedShape" ):
listener.enterAllocatedShape(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAllocatedShape" ):
listener.exitAllocatedShape(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAllocatedShape" ):
return visitor.visitAllocatedShape(self)
else:
return visitor.visitChildren(self)
[docs]
def allocatedShape(self):
localctx = Fortran90Parser.AllocatedShapeContext(self, self._ctx, self.state)
self.enterRule(localctx, 468, self.RULE_allocatedShape)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2550
self.match(Fortran90Parser.LPAREN)
self.state = 2551
self.sectionSubscriptList()
self.state = 2552
self.match(Fortran90Parser.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 StopStmtContext(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(Fortran90Parser.STOP, 0)
[docs]
def ICON(self):
return self.getToken(Fortran90Parser.ICON, 0)
[docs]
def SCON(self):
return self.getToken(Fortran90Parser.SCON, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_stopStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterStopStmt" ):
listener.enterStopStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitStopStmt" ):
listener.exitStopStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitStopStmt" ):
return visitor.visitStopStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def stopStmt(self):
localctx = Fortran90Parser.StopStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 470, self.RULE_stopStmt)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 2554
self.match(Fortran90Parser.STOP)
self.state = 2556
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,203,self._ctx)
if la_ == 1:
self.state = 2555
_la = self._input.LA(1)
if not(_la==Fortran90Parser.SCON or _la==Fortran90Parser.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 WriteStmtContext(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(Fortran90Parser.WRITE, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def ioControlSpecList(self):
return self.getTypedRuleContext(Fortran90Parser.IoControlSpecListContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def outputItemList(self):
return self.getTypedRuleContext(Fortran90Parser.OutputItemListContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_writeStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterWriteStmt" ):
listener.enterWriteStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitWriteStmt" ):
listener.exitWriteStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitWriteStmt" ):
return visitor.visitWriteStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def writeStmt(self):
localctx = Fortran90Parser.WriteStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 472, self.RULE_writeStmt)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2558
self.match(Fortran90Parser.WRITE)
self.state = 2559
self.match(Fortran90Parser.LPAREN)
self.state = 2560
self.ioControlSpecList(0)
self.state = 2561
self.match(Fortran90Parser.RPAREN)
self.state = 2563
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,204,self._ctx)
if la_ == 1:
self.state = 2562
self.outputItemList()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class IoControlSpecListContext(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(Fortran90Parser.UnitIdentifierContext,0)
[docs]
def DOLLAR(self):
return self.getToken(Fortran90Parser.DOLLAR, 0)
[docs]
def COMMA(self):
return self.getToken(Fortran90Parser.COMMA, 0)
[docs]
def formatIdentifier(self):
return self.getTypedRuleContext(Fortran90Parser.FormatIdentifierContext,0)
[docs]
def ioControlSpec(self):
return self.getTypedRuleContext(Fortran90Parser.IoControlSpecContext,0)
[docs]
def ioControlSpecList(self):
return self.getTypedRuleContext(Fortran90Parser.IoControlSpecListContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_ioControlSpecList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIoControlSpecList" ):
listener.enterIoControlSpecList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIoControlSpecList" ):
listener.exitIoControlSpecList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIoControlSpecList" ):
return visitor.visitIoControlSpecList(self)
else:
return visitor.visitChildren(self)
[docs]
def ioControlSpecList(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = Fortran90Parser.IoControlSpecListContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 474
self.enterRecursionRule(localctx, 474, self.RULE_ioControlSpecList, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2579
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,205,self._ctx)
if la_ == 1:
self.state = 2566
self.unitIdentifier()
self.state = 2567
self.match(Fortran90Parser.DOLLAR)
self.state = 2568
self.match(Fortran90Parser.COMMA)
pass
elif la_ == 2:
self.state = 2570
self.unitIdentifier()
self.state = 2571
self.match(Fortran90Parser.COMMA)
self.state = 2572
self.formatIdentifier()
pass
elif la_ == 3:
self.state = 2574
self.unitIdentifier()
self.state = 2575
self.match(Fortran90Parser.COMMA)
self.state = 2576
self.ioControlSpec()
pass
elif la_ == 4:
self.state = 2578
self.ioControlSpec()
pass
self._ctx.stop = self._input.LT(-1)
self.state = 2586
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,206,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = Fortran90Parser.IoControlSpecListContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_ioControlSpecList)
self.state = 2581
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 2582
self.match(Fortran90Parser.COMMA)
self.state = 2583
self.ioControlSpec()
self.state = 2588
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,206,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class StmtFunctionStmtContext(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(Fortran90Parser.NAME, 0)
[docs]
def stmtFunctionRange(self):
return self.getTypedRuleContext(Fortran90Parser.StmtFunctionRangeContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_stmtFunctionStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterStmtFunctionStmt" ):
listener.enterStmtFunctionStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitStmtFunctionStmt" ):
listener.exitStmtFunctionStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitStmtFunctionStmt" ):
return visitor.visitStmtFunctionStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def stmtFunctionStmt(self):
localctx = Fortran90Parser.StmtFunctionStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 476, self.RULE_stmtFunctionStmt)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2589
self.match(Fortran90Parser.NAME)
self.state = 2590
self.stmtFunctionRange()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class StmtFunctionRangeContext(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(Fortran90Parser.LPAREN, 0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran90Parser.ASSIGN, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,0)
[docs]
def sFDummyArgNameList(self):
return self.getTypedRuleContext(Fortran90Parser.SFDummyArgNameListContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_stmtFunctionRange
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterStmtFunctionRange" ):
listener.enterStmtFunctionRange(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitStmtFunctionRange" ):
listener.exitStmtFunctionRange(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitStmtFunctionRange" ):
return visitor.visitStmtFunctionRange(self)
else:
return visitor.visitChildren(self)
[docs]
def stmtFunctionRange(self):
localctx = Fortran90Parser.StmtFunctionRangeContext(self, self._ctx, self.state)
self.enterRule(localctx, 478, self.RULE_stmtFunctionRange)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 2592
self.match(Fortran90Parser.LPAREN)
self.state = 2594
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.NAME:
self.state = 2593
self.sFDummyArgNameList()
self.state = 2596
self.match(Fortran90Parser.RPAREN)
self.state = 2597
self.match(Fortran90Parser.ASSIGN)
self.state = 2598
self.expression(0)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class SFDummyArgNameListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def sFDummyArgName(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.SFDummyArgNameContext)
else:
return self.getTypedRuleContext(Fortran90Parser.SFDummyArgNameContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_sFDummyArgNameList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSFDummyArgNameList" ):
listener.enterSFDummyArgNameList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSFDummyArgNameList" ):
listener.exitSFDummyArgNameList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSFDummyArgNameList" ):
return visitor.visitSFDummyArgNameList(self)
else:
return visitor.visitChildren(self)
[docs]
def sFDummyArgNameList(self):
localctx = Fortran90Parser.SFDummyArgNameListContext(self, self._ctx, self.state)
self.enterRule(localctx, 480, self.RULE_sFDummyArgNameList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 2600
self.sFDummyArgName()
self.state = 2605
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran90Parser.COMMA:
self.state = 2601
self.match(Fortran90Parser.COMMA)
self.state = 2602
self.sFDummyArgName()
self.state = 2607
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 SFDummyArgNameContext(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(Fortran90Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_sFDummyArgName
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSFDummyArgName" ):
listener.enterSFDummyArgName(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSFDummyArgName" ):
listener.exitSFDummyArgName(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSFDummyArgName" ):
return visitor.visitSFDummyArgName(self)
else:
return visitor.visitChildren(self)
[docs]
def sFDummyArgName(self):
localctx = Fortran90Parser.SFDummyArgNameContext(self, self._ctx, self.state)
self.enterRule(localctx, 482, self.RULE_sFDummyArgName)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2608
self.match(Fortran90Parser.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 ReturnStmtContext(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(Fortran90Parser.RETURN, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_returnStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterReturnStmt" ):
listener.enterReturnStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitReturnStmt" ):
listener.exitReturnStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitReturnStmt" ):
return visitor.visitReturnStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def returnStmt(self):
localctx = Fortran90Parser.ReturnStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 484, self.RULE_returnStmt)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2610
self.match(Fortran90Parser.RETURN)
self.state = 2612
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,209,self._ctx)
if la_ == 1:
self.state = 2611
self.expression(0)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class RewindStmtContext(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(Fortran90Parser.REWIND, 0)
[docs]
def unitIdentifier(self):
return self.getTypedRuleContext(Fortran90Parser.UnitIdentifierContext,0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def positionSpecList(self):
return self.getTypedRuleContext(Fortran90Parser.PositionSpecListContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_rewindStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterRewindStmt" ):
listener.enterRewindStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitRewindStmt" ):
listener.exitRewindStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitRewindStmt" ):
return visitor.visitRewindStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def rewindStmt(self):
localctx = Fortran90Parser.RewindStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 486, self.RULE_rewindStmt)
try:
self.state = 2621
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,210,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2614
self.match(Fortran90Parser.REWIND)
self.state = 2615
self.unitIdentifier()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2616
self.match(Fortran90Parser.REWIND)
self.state = 2617
self.match(Fortran90Parser.LPAREN)
self.state = 2618
self.positionSpecList()
self.state = 2619
self.match(Fortran90Parser.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 ReadStmtContext(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(Fortran90Parser.READ, 0)
[docs]
def rdCtlSpec(self):
return self.getTypedRuleContext(Fortran90Parser.RdCtlSpecContext,0)
[docs]
def inputItemList(self):
return self.getTypedRuleContext(Fortran90Parser.InputItemListContext,0)
[docs]
def rdFmtId(self):
return self.getTypedRuleContext(Fortran90Parser.RdFmtIdContext,0)
[docs]
def commaInputItemList(self):
return self.getTypedRuleContext(Fortran90Parser.CommaInputItemListContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_readStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterReadStmt" ):
listener.enterReadStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitReadStmt" ):
listener.exitReadStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitReadStmt" ):
return visitor.visitReadStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def readStmt(self):
localctx = Fortran90Parser.ReadStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 488, self.RULE_readStmt)
try:
self.state = 2633
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,213,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2623
self.match(Fortran90Parser.READ)
self.state = 2624
self.rdCtlSpec()
self.state = 2626
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,211,self._ctx)
if la_ == 1:
self.state = 2625
self.inputItemList()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2628
self.match(Fortran90Parser.READ)
self.state = 2629
self.rdFmtId()
self.state = 2631
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,212,self._ctx)
if la_ == 1:
self.state = 2630
self.commaInputItemList()
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 CommaInputItemListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def COMMA(self):
return self.getToken(Fortran90Parser.COMMA, 0)
[docs]
def inputItemList(self):
return self.getTypedRuleContext(Fortran90Parser.InputItemListContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_commaInputItemList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCommaInputItemList" ):
listener.enterCommaInputItemList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCommaInputItemList" ):
listener.exitCommaInputItemList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCommaInputItemList" ):
return visitor.visitCommaInputItemList(self)
else:
return visitor.visitChildren(self)
[docs]
def commaInputItemList(self):
localctx = Fortran90Parser.CommaInputItemListContext(self, self._ctx, self.state)
self.enterRule(localctx, 490, self.RULE_commaInputItemList)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2635
self.match(Fortran90Parser.COMMA)
self.state = 2636
self.inputItemList()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class RdFmtIdContext(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(Fortran90Parser.LblRefContext,0)
[docs]
def STAR(self):
return self.getToken(Fortran90Parser.STAR, 0)
[docs]
def cOperand(self):
return self.getTypedRuleContext(Fortran90Parser.COperandContext,0)
[docs]
def DIV(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.DIV)
else:
return self.getToken(Fortran90Parser.DIV, i)
[docs]
def SPOFF(self):
return self.getToken(Fortran90Parser.SPOFF, 0)
[docs]
def SPON(self):
return self.getToken(Fortran90Parser.SPON, 0)
[docs]
def cPrimary(self):
return self.getTypedRuleContext(Fortran90Parser.CPrimaryContext,0)
[docs]
def rdFmtIdExpr(self):
return self.getTypedRuleContext(Fortran90Parser.RdFmtIdExprContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_rdFmtId
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterRdFmtId" ):
listener.enterRdFmtId(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitRdFmtId" ):
listener.exitRdFmtId(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitRdFmtId" ):
return visitor.visitRdFmtId(self)
else:
return visitor.visitChildren(self)
[docs]
def rdFmtId(self):
localctx = Fortran90Parser.RdFmtIdContext(self, self._ctx, self.state)
self.enterRule(localctx, 492, self.RULE_rdFmtId)
try:
self.state = 2655
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,214,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2638
self.lblRef()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2639
self.match(Fortran90Parser.STAR)
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 2640
self.cOperand()
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 2641
self.cOperand()
self.state = 2642
self.match(Fortran90Parser.DIV)
self.state = 2643
self.match(Fortran90Parser.SPOFF)
self.state = 2644
self.match(Fortran90Parser.DIV)
self.state = 2645
self.match(Fortran90Parser.SPON)
self.state = 2646
self.cPrimary()
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 2648
self.rdFmtIdExpr()
self.state = 2649
self.match(Fortran90Parser.DIV)
self.state = 2650
self.match(Fortran90Parser.SPOFF)
self.state = 2651
self.match(Fortran90Parser.DIV)
self.state = 2652
self.match(Fortran90Parser.SPON)
self.state = 2653
self.cPrimary()
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 RdFmtIdExprContext(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(Fortran90Parser.LPAREN, 0)
[docs]
def uFExpr(self):
return self.getTypedRuleContext(Fortran90Parser.UFExprContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_rdFmtIdExpr
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterRdFmtIdExpr" ):
listener.enterRdFmtIdExpr(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitRdFmtIdExpr" ):
listener.exitRdFmtIdExpr(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitRdFmtIdExpr" ):
return visitor.visitRdFmtIdExpr(self)
else:
return visitor.visitChildren(self)
[docs]
def rdFmtIdExpr(self):
localctx = Fortran90Parser.RdFmtIdExprContext(self, self._ctx, self.state)
self.enterRule(localctx, 494, self.RULE_rdFmtIdExpr)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2657
self.match(Fortran90Parser.LPAREN)
self.state = 2658
self.uFExpr(0)
self.state = 2659
self.match(Fortran90Parser.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 InputItemListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def inputItem(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.InputItemContext)
else:
return self.getTypedRuleContext(Fortran90Parser.InputItemContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_inputItemList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterInputItemList" ):
listener.enterInputItemList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitInputItemList" ):
listener.exitInputItemList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitInputItemList" ):
return visitor.visitInputItemList(self)
else:
return visitor.visitChildren(self)
[docs]
class InputItemContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def nameDataRef(self):
return self.getTypedRuleContext(Fortran90Parser.NameDataRefContext,0)
[docs]
def inputImpliedDo(self):
return self.getTypedRuleContext(Fortran90Parser.InputImpliedDoContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_inputItem
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterInputItem" ):
listener.enterInputItem(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitInputItem" ):
listener.exitInputItem(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitInputItem" ):
return visitor.visitInputItem(self)
else:
return visitor.visitChildren(self)
[docs]
class InputImpliedDoContext(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(Fortran90Parser.LPAREN, 0)
[docs]
def inputItemList(self):
return self.getTypedRuleContext(Fortran90Parser.InputItemListContext,0)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def impliedDoVariable(self):
return self.getTypedRuleContext(Fortran90Parser.ImpliedDoVariableContext,0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran90Parser.ASSIGN, 0)
[docs]
def expression(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.ExpressionContext)
else:
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,i)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def commaExpr(self):
return self.getTypedRuleContext(Fortran90Parser.CommaExprContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_inputImpliedDo
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterInputImpliedDo" ):
listener.enterInputImpliedDo(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitInputImpliedDo" ):
listener.exitInputImpliedDo(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitInputImpliedDo" ):
return visitor.visitInputImpliedDo(self)
else:
return visitor.visitChildren(self)
[docs]
class RdCtlSpecContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def rdUnitId(self):
return self.getTypedRuleContext(Fortran90Parser.RdUnitIdContext,0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def rdIoCtlSpecList(self):
return self.getTypedRuleContext(Fortran90Parser.RdIoCtlSpecListContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_rdCtlSpec
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterRdCtlSpec" ):
listener.enterRdCtlSpec(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitRdCtlSpec" ):
listener.exitRdCtlSpec(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitRdCtlSpec" ):
return visitor.visitRdCtlSpec(self)
else:
return visitor.visitChildren(self)
[docs]
def rdCtlSpec(self):
localctx = Fortran90Parser.RdCtlSpecContext(self, self._ctx, self.state)
self.enterRule(localctx, 502, self.RULE_rdCtlSpec)
try:
self.state = 2691
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,218,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2686
self.rdUnitId()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2687
self.match(Fortran90Parser.LPAREN)
self.state = 2688
self.rdIoCtlSpecList(0)
self.state = 2689
self.match(Fortran90Parser.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 RdUnitIdContext(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(Fortran90Parser.LPAREN, 0)
[docs]
def uFExpr(self):
return self.getTypedRuleContext(Fortran90Parser.UFExprContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def STAR(self):
return self.getToken(Fortran90Parser.STAR, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_rdUnitId
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterRdUnitId" ):
listener.enterRdUnitId(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitRdUnitId" ):
listener.exitRdUnitId(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitRdUnitId" ):
return visitor.visitRdUnitId(self)
else:
return visitor.visitChildren(self)
[docs]
def rdUnitId(self):
localctx = Fortran90Parser.RdUnitIdContext(self, self._ctx, self.state)
self.enterRule(localctx, 504, self.RULE_rdUnitId)
try:
self.state = 2700
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,219,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2693
self.match(Fortran90Parser.LPAREN)
self.state = 2694
self.uFExpr(0)
self.state = 2695
self.match(Fortran90Parser.RPAREN)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2697
self.match(Fortran90Parser.LPAREN)
self.state = 2698
self.match(Fortran90Parser.STAR)
self.state = 2699
self.match(Fortran90Parser.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 RdIoCtlSpecListContext(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(Fortran90Parser.UnitIdentifierContext,0)
[docs]
def COMMA(self):
return self.getToken(Fortran90Parser.COMMA, 0)
[docs]
def ioControlSpec(self):
return self.getTypedRuleContext(Fortran90Parser.IoControlSpecContext,0)
[docs]
def formatIdentifier(self):
return self.getTypedRuleContext(Fortran90Parser.FormatIdentifierContext,0)
[docs]
def rdIoCtlSpecList(self):
return self.getTypedRuleContext(Fortran90Parser.RdIoCtlSpecListContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_rdIoCtlSpecList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterRdIoCtlSpecList" ):
listener.enterRdIoCtlSpecList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitRdIoCtlSpecList" ):
listener.exitRdIoCtlSpecList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitRdIoCtlSpecList" ):
return visitor.visitRdIoCtlSpecList(self)
else:
return visitor.visitChildren(self)
[docs]
def rdIoCtlSpecList(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = Fortran90Parser.RdIoCtlSpecListContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 506
self.enterRecursionRule(localctx, 506, self.RULE_rdIoCtlSpecList, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2712
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,220,self._ctx)
if la_ == 1:
self.state = 2703
self.unitIdentifier()
self.state = 2704
self.match(Fortran90Parser.COMMA)
self.state = 2705
self.ioControlSpec()
pass
elif la_ == 2:
self.state = 2707
self.unitIdentifier()
self.state = 2708
self.match(Fortran90Parser.COMMA)
self.state = 2709
self.formatIdentifier()
pass
elif la_ == 3:
self.state = 2711
self.ioControlSpec()
pass
self._ctx.stop = self._input.LT(-1)
self.state = 2719
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,221,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = Fortran90Parser.RdIoCtlSpecListContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_rdIoCtlSpecList)
self.state = 2714
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 2715
self.match(Fortran90Parser.COMMA)
self.state = 2716
self.ioControlSpec()
self.state = 2721
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,221,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class IoControlSpecContext(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(Fortran90Parser.FMT, 0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran90Parser.ASSIGN, 0)
[docs]
def formatIdentifier(self):
return self.getTypedRuleContext(Fortran90Parser.FormatIdentifierContext,0)
[docs]
def UNIT(self):
return self.getToken(Fortran90Parser.UNIT, 0)
[docs]
def unitIdentifier(self):
return self.getTypedRuleContext(Fortran90Parser.UnitIdentifierContext,0)
[docs]
def REC(self):
return self.getToken(Fortran90Parser.REC, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,0)
[docs]
def END(self):
return self.getToken(Fortran90Parser.END, 0)
[docs]
def lblRef(self):
return self.getTypedRuleContext(Fortran90Parser.LblRefContext,0)
[docs]
def ERR(self):
return self.getToken(Fortran90Parser.ERR, 0)
[docs]
def IOSTAT(self):
return self.getToken(Fortran90Parser.IOSTAT, 0)
[docs]
def scalarVariable(self):
return self.getTypedRuleContext(Fortran90Parser.ScalarVariableContext,0)
[docs]
def NML(self):
return self.getToken(Fortran90Parser.NML, 0)
[docs]
def namelistGroupName(self):
return self.getTypedRuleContext(Fortran90Parser.NamelistGroupNameContext,0)
[docs]
def ADVANCE(self):
return self.getToken(Fortran90Parser.ADVANCE, 0)
[docs]
def cExpression(self):
return self.getTypedRuleContext(Fortran90Parser.CExpressionContext,0)
[docs]
def SIZE(self):
return self.getToken(Fortran90Parser.SIZE, 0)
[docs]
def variable(self):
return self.getTypedRuleContext(Fortran90Parser.VariableContext,0)
[docs]
def EOR(self):
return self.getToken(Fortran90Parser.EOR, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_ioControlSpec
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIoControlSpec" ):
listener.enterIoControlSpec(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIoControlSpec" ):
listener.exitIoControlSpec(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIoControlSpec" ):
return visitor.visitIoControlSpec(self)
else:
return visitor.visitChildren(self)
[docs]
def ioControlSpec(self):
localctx = Fortran90Parser.IoControlSpecContext(self, self._ctx, self.state)
self.enterRule(localctx, 508, self.RULE_ioControlSpec)
try:
self.state = 2752
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.FMT]:
self.enterOuterAlt(localctx, 1)
self.state = 2722
self.match(Fortran90Parser.FMT)
self.state = 2723
self.match(Fortran90Parser.ASSIGN)
self.state = 2724
self.formatIdentifier()
pass
elif token in [Fortran90Parser.UNIT]:
self.enterOuterAlt(localctx, 2)
self.state = 2725
self.match(Fortran90Parser.UNIT)
self.state = 2726
self.match(Fortran90Parser.ASSIGN)
self.state = 2727
self.unitIdentifier()
pass
elif token in [Fortran90Parser.REC]:
self.enterOuterAlt(localctx, 3)
self.state = 2728
self.match(Fortran90Parser.REC)
self.state = 2729
self.match(Fortran90Parser.ASSIGN)
self.state = 2730
self.expression(0)
pass
elif token in [Fortran90Parser.END]:
self.enterOuterAlt(localctx, 4)
self.state = 2731
self.match(Fortran90Parser.END)
self.state = 2732
self.match(Fortran90Parser.ASSIGN)
self.state = 2733
self.lblRef()
pass
elif token in [Fortran90Parser.ERR]:
self.enterOuterAlt(localctx, 5)
self.state = 2734
self.match(Fortran90Parser.ERR)
self.state = 2735
self.match(Fortran90Parser.ASSIGN)
self.state = 2736
self.lblRef()
pass
elif token in [Fortran90Parser.IOSTAT]:
self.enterOuterAlt(localctx, 6)
self.state = 2737
self.match(Fortran90Parser.IOSTAT)
self.state = 2738
self.match(Fortran90Parser.ASSIGN)
self.state = 2739
self.scalarVariable()
pass
elif token in [Fortran90Parser.NML]:
self.enterOuterAlt(localctx, 7)
self.state = 2740
self.match(Fortran90Parser.NML)
self.state = 2741
self.match(Fortran90Parser.ASSIGN)
self.state = 2742
self.namelistGroupName()
pass
elif token in [Fortran90Parser.ADVANCE]:
self.enterOuterAlt(localctx, 8)
self.state = 2743
self.match(Fortran90Parser.ADVANCE)
self.state = 2744
self.match(Fortran90Parser.ASSIGN)
self.state = 2745
self.cExpression()
pass
elif token in [Fortran90Parser.SIZE]:
self.enterOuterAlt(localctx, 9)
self.state = 2746
self.match(Fortran90Parser.SIZE)
self.state = 2747
self.match(Fortran90Parser.ASSIGN)
self.state = 2748
self.variable()
pass
elif token in [Fortran90Parser.EOR]:
self.enterOuterAlt(localctx, 10)
self.state = 2749
self.match(Fortran90Parser.EOR)
self.state = 2750
self.match(Fortran90Parser.ASSIGN)
self.state = 2751
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 PrintStmtContext(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(Fortran90Parser.PRINT, 0)
[docs]
def formatIdentifier(self):
return self.getTypedRuleContext(Fortran90Parser.FormatIdentifierContext,0)
[docs]
def COMMA(self):
return self.getToken(Fortran90Parser.COMMA, 0)
[docs]
def outputItemList(self):
return self.getTypedRuleContext(Fortran90Parser.OutputItemListContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_printStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPrintStmt" ):
listener.enterPrintStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPrintStmt" ):
listener.exitPrintStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPrintStmt" ):
return visitor.visitPrintStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def printStmt(self):
localctx = Fortran90Parser.PrintStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 510, self.RULE_printStmt)
try:
self.state = 2761
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,223,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2754
self.match(Fortran90Parser.PRINT)
self.state = 2755
self.formatIdentifier()
self.state = 2756
self.match(Fortran90Parser.COMMA)
self.state = 2757
self.outputItemList()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2759
self.match(Fortran90Parser.PRINT)
self.state = 2760
self.formatIdentifier()
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 OutputItemListContext(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(Fortran90Parser.ExpressionContext,0)
[docs]
def outputItemList1(self):
return self.getTypedRuleContext(Fortran90Parser.OutputItemList1Context,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_outputItemList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterOutputItemList" ):
listener.enterOutputItemList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitOutputItemList" ):
listener.exitOutputItemList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitOutputItemList" ):
return visitor.visitOutputItemList(self)
else:
return visitor.visitChildren(self)
[docs]
def outputItemList(self):
localctx = Fortran90Parser.OutputItemListContext(self, self._ctx, self.state)
self.enterRule(localctx, 512, self.RULE_outputItemList)
try:
self.state = 2765
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,224,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2763
self.expression(0)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2764
self.outputItemList1(0)
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 OutputItemList1Context(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def expression(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.ExpressionContext)
else:
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,i)
[docs]
def COMMA(self):
return self.getToken(Fortran90Parser.COMMA, 0)
[docs]
def outputImpliedDo(self):
return self.getTypedRuleContext(Fortran90Parser.OutputImpliedDoContext,0)
[docs]
def outputItemList1(self):
return self.getTypedRuleContext(Fortran90Parser.OutputItemList1Context,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_outputItemList1
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterOutputItemList1" ):
listener.enterOutputItemList1(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitOutputItemList1" ):
listener.exitOutputItemList1(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitOutputItemList1" ):
return visitor.visitOutputItemList1(self)
else:
return visitor.visitChildren(self)
[docs]
def outputItemList1(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = Fortran90Parser.OutputItemList1Context(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 514
self.enterRecursionRule(localctx, 514, self.RULE_outputItemList1, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2777
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,225,self._ctx)
if la_ == 1:
self.state = 2768
self.expression(0)
self.state = 2769
self.match(Fortran90Parser.COMMA)
self.state = 2770
self.expression(0)
pass
elif la_ == 2:
self.state = 2772
self.expression(0)
self.state = 2773
self.match(Fortran90Parser.COMMA)
self.state = 2774
self.outputImpliedDo()
pass
elif la_ == 3:
self.state = 2776
self.outputImpliedDo()
pass
self._ctx.stop = self._input.LT(-1)
self.state = 2787
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,227,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
self.state = 2785
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,226,self._ctx)
if la_ == 1:
localctx = Fortran90Parser.OutputItemList1Context(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_outputItemList1)
self.state = 2779
if not self.precpred(self._ctx, 2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
self.state = 2780
self.match(Fortran90Parser.COMMA)
self.state = 2781
self.expression(0)
pass
elif la_ == 2:
localctx = Fortran90Parser.OutputItemList1Context(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_outputItemList1)
self.state = 2782
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 2783
self.match(Fortran90Parser.COMMA)
self.state = 2784
self.outputImpliedDo()
pass
self.state = 2789
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,227,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class OutputImpliedDoContext(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(Fortran90Parser.LPAREN, 0)
[docs]
def expression(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.ExpressionContext)
else:
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def impliedDoVariable(self):
return self.getTypedRuleContext(Fortran90Parser.ImpliedDoVariableContext,0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran90Parser.ASSIGN, 0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def commaExpr(self):
return self.getTypedRuleContext(Fortran90Parser.CommaExprContext,0)
[docs]
def outputItemList1(self):
return self.getTypedRuleContext(Fortran90Parser.OutputItemList1Context,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_outputImpliedDo
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterOutputImpliedDo" ):
listener.enterOutputImpliedDo(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitOutputImpliedDo" ):
listener.exitOutputImpliedDo(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitOutputImpliedDo" ):
return visitor.visitOutputImpliedDo(self)
else:
return visitor.visitChildren(self)
[docs]
def outputImpliedDo(self):
localctx = Fortran90Parser.OutputImpliedDoContext(self, self._ctx, self.state)
self.enterRule(localctx, 516, self.RULE_outputImpliedDo)
self._la = 0 # Token type
try:
self.state = 2816
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,230,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2790
self.match(Fortran90Parser.LPAREN)
self.state = 2791
self.expression(0)
self.state = 2792
self.match(Fortran90Parser.COMMA)
self.state = 2793
self.impliedDoVariable()
self.state = 2794
self.match(Fortran90Parser.ASSIGN)
self.state = 2795
self.expression(0)
self.state = 2796
self.match(Fortran90Parser.COMMA)
self.state = 2797
self.expression(0)
self.state = 2799
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.COMMA:
self.state = 2798
self.commaExpr()
self.state = 2801
self.match(Fortran90Parser.RPAREN)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2803
self.match(Fortran90Parser.LPAREN)
self.state = 2804
self.outputItemList1(0)
self.state = 2805
self.match(Fortran90Parser.COMMA)
self.state = 2806
self.impliedDoVariable()
self.state = 2807
self.match(Fortran90Parser.ASSIGN)
self.state = 2808
self.expression(0)
self.state = 2809
self.match(Fortran90Parser.COMMA)
self.state = 2810
self.expression(0)
self.state = 2812
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.COMMA:
self.state = 2811
self.commaExpr()
self.state = 2814
self.match(Fortran90Parser.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 FormatIdentifierContext(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(Fortran90Parser.LblRefContext,0)
[docs]
def cExpression(self):
return self.getTypedRuleContext(Fortran90Parser.CExpressionContext,0)
[docs]
def STAR(self):
return self.getToken(Fortran90Parser.STAR, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.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 PauseStmtContext(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(Fortran90Parser.PAUSE, 0)
[docs]
def ICON(self):
return self.getToken(Fortran90Parser.ICON, 0)
[docs]
def SCON(self):
return self.getToken(Fortran90Parser.SCON, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_pauseStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPauseStmt" ):
listener.enterPauseStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPauseStmt" ):
listener.exitPauseStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPauseStmt" ):
return visitor.visitPauseStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def pauseStmt(self):
localctx = Fortran90Parser.PauseStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 520, self.RULE_pauseStmt)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 2823
self.match(Fortran90Parser.PAUSE)
self.state = 2825
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,232,self._ctx)
if la_ == 1:
self.state = 2824
_la = self._input.LA(1)
if not(_la==Fortran90Parser.SCON or _la==Fortran90Parser.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 OpenStmtContext(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(Fortran90Parser.OPEN, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def connectSpecList(self):
return self.getTypedRuleContext(Fortran90Parser.ConnectSpecListContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_openStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterOpenStmt" ):
listener.enterOpenStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitOpenStmt" ):
listener.exitOpenStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitOpenStmt" ):
return visitor.visitOpenStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def openStmt(self):
localctx = Fortran90Parser.OpenStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 522, self.RULE_openStmt)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2827
self.match(Fortran90Parser.OPEN)
self.state = 2828
self.match(Fortran90Parser.LPAREN)
self.state = 2829
self.connectSpecList()
self.state = 2830
self.match(Fortran90Parser.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 ConnectSpecListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def unitIdentifierComma(self):
return self.getTypedRuleContext(Fortran90Parser.UnitIdentifierCommaContext,0)
[docs]
def connectSpec(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.ConnectSpecContext)
else:
return self.getTypedRuleContext(Fortran90Parser.ConnectSpecContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_connectSpecList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterConnectSpecList" ):
listener.enterConnectSpecList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitConnectSpecList" ):
listener.exitConnectSpecList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitConnectSpecList" ):
return visitor.visitConnectSpecList(self)
else:
return visitor.visitChildren(self)
[docs]
def connectSpecList(self):
localctx = Fortran90Parser.ConnectSpecListContext(self, self._ctx, self.state)
self.enterRule(localctx, 524, self.RULE_connectSpecList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 2833
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.REAL or ((((_la - 84)) & ~0x3f) == 0 and ((1 << (_la - 84)) & ((1 << (Fortran90Parser.SIZE - 84)) | (1 << (Fortran90Parser.LPAREN - 84)) | (1 << (Fortran90Parser.MINUS - 84)) | (1 << (Fortran90Parser.PLUS - 84)))) != 0) or ((((_la - 177)) & ~0x3f) == 0 and ((1 << (_la - 177)) & ((1 << (Fortran90Parser.SCON - 177)) | (1 << (Fortran90Parser.ICON - 177)) | (1 << (Fortran90Parser.NAME - 177)) | (1 << (Fortran90Parser.STAR - 177)))) != 0):
self.state = 2832
self.unitIdentifierComma()
self.state = 2836
self._errHandler.sync(self)
_la = self._input.LA(1)
if ((((_la - 77)) & ~0x3f) == 0 and ((1 << (_la - 77)) & ((1 << (Fortran90Parser.UNIT - 77)) | (1 << (Fortran90Parser.PAD - 77)) | (1 << (Fortran90Parser.ACTION - 77)) | (1 << (Fortran90Parser.DELIM - 77)) | (1 << (Fortran90Parser.ERR - 77)) | (1 << (Fortran90Parser.IOSTAT - 77)) | (1 << (Fortran90Parser.FILE - 77)) | (1 << (Fortran90Parser.STATUS - 77)) | (1 << (Fortran90Parser.ACCESS - 77)) | (1 << (Fortran90Parser.POSITION - 77)) | (1 << (Fortran90Parser.FORM - 77)) | (1 << (Fortran90Parser.RECL - 77)))) != 0) or _la==Fortran90Parser.BLANK:
self.state = 2835
self.connectSpec()
self.state = 2842
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran90Parser.COMMA:
self.state = 2838
self.match(Fortran90Parser.COMMA)
self.state = 2839
self.connectSpec()
self.state = 2844
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 ConnectSpecContext(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(Fortran90Parser.UNIT, 0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran90Parser.ASSIGN, 0)
[docs]
def unitIdentifier(self):
return self.getTypedRuleContext(Fortran90Parser.UnitIdentifierContext,0)
[docs]
def ERR(self):
return self.getToken(Fortran90Parser.ERR, 0)
[docs]
def lblRef(self):
return self.getTypedRuleContext(Fortran90Parser.LblRefContext,0)
[docs]
def FILE(self):
return self.getToken(Fortran90Parser.FILE, 0)
[docs]
def cExpression(self):
return self.getTypedRuleContext(Fortran90Parser.CExpressionContext,0)
[docs]
def STATUS(self):
return self.getToken(Fortran90Parser.STATUS, 0)
[docs]
def ACCESS(self):
return self.getToken(Fortran90Parser.ACCESS, 0)
[docs]
def FORM(self):
return self.getToken(Fortran90Parser.FORM, 0)
[docs]
def RECL(self):
return self.getToken(Fortran90Parser.RECL, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,0)
[docs]
def BLANK(self):
return self.getToken(Fortran90Parser.BLANK, 0)
[docs]
def IOSTAT(self):
return self.getToken(Fortran90Parser.IOSTAT, 0)
[docs]
def scalarVariable(self):
return self.getTypedRuleContext(Fortran90Parser.ScalarVariableContext,0)
[docs]
def POSITION(self):
return self.getToken(Fortran90Parser.POSITION, 0)
[docs]
def ACTION(self):
return self.getToken(Fortran90Parser.ACTION, 0)
[docs]
def DELIM(self):
return self.getToken(Fortran90Parser.DELIM, 0)
[docs]
def PAD(self):
return self.getToken(Fortran90Parser.PAD, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_connectSpec
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterConnectSpec" ):
listener.enterConnectSpec(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitConnectSpec" ):
listener.exitConnectSpec(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitConnectSpec" ):
return visitor.visitConnectSpec(self)
else:
return visitor.visitChildren(self)
[docs]
def connectSpec(self):
localctx = Fortran90Parser.ConnectSpecContext(self, self._ctx, self.state)
self.enterRule(localctx, 526, self.RULE_connectSpec)
try:
self.state = 2884
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.UNIT]:
self.enterOuterAlt(localctx, 1)
self.state = 2845
self.match(Fortran90Parser.UNIT)
self.state = 2846
self.match(Fortran90Parser.ASSIGN)
self.state = 2847
self.unitIdentifier()
pass
elif token in [Fortran90Parser.ERR]:
self.enterOuterAlt(localctx, 2)
self.state = 2848
self.match(Fortran90Parser.ERR)
self.state = 2849
self.match(Fortran90Parser.ASSIGN)
self.state = 2850
self.lblRef()
pass
elif token in [Fortran90Parser.FILE]:
self.enterOuterAlt(localctx, 3)
self.state = 2851
self.match(Fortran90Parser.FILE)
self.state = 2852
self.match(Fortran90Parser.ASSIGN)
self.state = 2853
self.cExpression()
pass
elif token in [Fortran90Parser.STATUS]:
self.enterOuterAlt(localctx, 4)
self.state = 2854
self.match(Fortran90Parser.STATUS)
self.state = 2855
self.match(Fortran90Parser.ASSIGN)
self.state = 2856
self.cExpression()
pass
elif token in [Fortran90Parser.ACCESS]:
self.enterOuterAlt(localctx, 5)
self.state = 2857
self.match(Fortran90Parser.ACCESS)
self.state = 2858
self.match(Fortran90Parser.ASSIGN)
self.state = 2859
self.cExpression()
pass
elif token in [Fortran90Parser.FORM]:
self.enterOuterAlt(localctx, 6)
self.state = 2860
self.match(Fortran90Parser.FORM)
self.state = 2861
self.match(Fortran90Parser.ASSIGN)
self.state = 2862
self.cExpression()
pass
elif token in [Fortran90Parser.RECL]:
self.enterOuterAlt(localctx, 7)
self.state = 2863
self.match(Fortran90Parser.RECL)
self.state = 2864
self.match(Fortran90Parser.ASSIGN)
self.state = 2865
self.expression(0)
pass
elif token in [Fortran90Parser.BLANK]:
self.enterOuterAlt(localctx, 8)
self.state = 2866
self.match(Fortran90Parser.BLANK)
self.state = 2867
self.match(Fortran90Parser.ASSIGN)
self.state = 2868
self.cExpression()
pass
elif token in [Fortran90Parser.IOSTAT]:
self.enterOuterAlt(localctx, 9)
self.state = 2869
self.match(Fortran90Parser.IOSTAT)
self.state = 2870
self.match(Fortran90Parser.ASSIGN)
self.state = 2871
self.scalarVariable()
pass
elif token in [Fortran90Parser.POSITION]:
self.enterOuterAlt(localctx, 10)
self.state = 2872
self.match(Fortran90Parser.POSITION)
self.state = 2873
self.match(Fortran90Parser.ASSIGN)
self.state = 2874
self.cExpression()
pass
elif token in [Fortran90Parser.ACTION]:
self.enterOuterAlt(localctx, 11)
self.state = 2875
self.match(Fortran90Parser.ACTION)
self.state = 2876
self.match(Fortran90Parser.ASSIGN)
self.state = 2877
self.cExpression()
pass
elif token in [Fortran90Parser.DELIM]:
self.enterOuterAlt(localctx, 12)
self.state = 2878
self.match(Fortran90Parser.DELIM)
self.state = 2879
self.match(Fortran90Parser.ASSIGN)
self.state = 2880
self.cExpression()
pass
elif token in [Fortran90Parser.PAD]:
self.enterOuterAlt(localctx, 13)
self.state = 2881
self.match(Fortran90Parser.PAD)
self.state = 2882
self.match(Fortran90Parser.ASSIGN)
self.state = 2883
self.cExpression()
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 InquireStmtContext(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(Fortran90Parser.INQUIRE, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def inquireSpecList(self):
return self.getTypedRuleContext(Fortran90Parser.InquireSpecListContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def IOLENGTH(self):
return self.getToken(Fortran90Parser.IOLENGTH, 0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran90Parser.ASSIGN, 0)
[docs]
def scalarVariable(self):
return self.getTypedRuleContext(Fortran90Parser.ScalarVariableContext,0)
[docs]
def outputItemList(self):
return self.getTypedRuleContext(Fortran90Parser.OutputItemListContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_inquireStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterInquireStmt" ):
listener.enterInquireStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitInquireStmt" ):
listener.exitInquireStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitInquireStmt" ):
return visitor.visitInquireStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def inquireStmt(self):
localctx = Fortran90Parser.InquireStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 528, self.RULE_inquireStmt)
try:
self.state = 2899
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,237,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2886
self.match(Fortran90Parser.INQUIRE)
self.state = 2887
self.match(Fortran90Parser.LPAREN)
self.state = 2888
self.inquireSpecList()
self.state = 2889
self.match(Fortran90Parser.RPAREN)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2891
self.match(Fortran90Parser.INQUIRE)
self.state = 2892
self.match(Fortran90Parser.LPAREN)
self.state = 2893
self.match(Fortran90Parser.IOLENGTH)
self.state = 2894
self.match(Fortran90Parser.ASSIGN)
self.state = 2895
self.scalarVariable()
self.state = 2896
self.match(Fortran90Parser.RPAREN)
self.state = 2897
self.outputItemList()
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 InquireSpecListContext(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(Fortran90Parser.UnitIdentifierContext,0)
[docs]
def inquireSpec(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.InquireSpecContext)
else:
return self.getTypedRuleContext(Fortran90Parser.InquireSpecContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_inquireSpecList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterInquireSpecList" ):
listener.enterInquireSpecList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitInquireSpecList" ):
listener.exitInquireSpecList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitInquireSpecList" ):
return visitor.visitInquireSpecList(self)
else:
return visitor.visitChildren(self)
[docs]
def inquireSpecList(self):
localctx = Fortran90Parser.InquireSpecListContext(self, self._ctx, self.state)
self.enterRule(localctx, 530, self.RULE_inquireSpecList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 2902
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,238,self._ctx)
if la_ == 1:
self.state = 2901
self.unitIdentifier()
self.state = 2905
self._errHandler.sync(self)
_la = self._input.LA(1)
if ((((_la - 67)) & ~0x3f) == 0 and ((1 << (_la - 67)) & ((1 << (Fortran90Parser.DIRECT - 67)) | (1 << (Fortran90Parser.WRITE - 67)) | (1 << (Fortran90Parser.READ - 67)) | (1 << (Fortran90Parser.UNIT - 67)) | (1 << (Fortran90Parser.PAD - 67)) | (1 << (Fortran90Parser.ACTION - 67)) | (1 << (Fortran90Parser.DELIM - 67)) | (1 << (Fortran90Parser.READWRITE - 67)) | (1 << (Fortran90Parser.ERR - 67)) | (1 << (Fortran90Parser.IOSTAT - 67)) | (1 << (Fortran90Parser.SEQUENTIAL - 67)) | (1 << (Fortran90Parser.FILE - 67)) | (1 << (Fortran90Parser.ACCESS - 67)) | (1 << (Fortran90Parser.POSITION - 67)) | (1 << (Fortran90Parser.FORM - 67)) | (1 << (Fortran90Parser.RECL - 67)) | (1 << (Fortran90Parser.EXIST - 67)) | (1 << (Fortran90Parser.OPENED - 67)) | (1 << (Fortran90Parser.NUMBER - 67)) | (1 << (Fortran90Parser.NAMED - 67)) | (1 << (Fortran90Parser.FORMATTED - 67)) | (1 << (Fortran90Parser.UNFORMATTED - 67)) | (1 << (Fortran90Parser.NEXTREC - 67)))) != 0) or _la==Fortran90Parser.NAME or _la==Fortran90Parser.BLANK:
self.state = 2904
self.inquireSpec()
self.state = 2911
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran90Parser.COMMA:
self.state = 2907
self.match(Fortran90Parser.COMMA)
self.state = 2908
self.inquireSpec()
self.state = 2913
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 InquireSpecContext(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(Fortran90Parser.UNIT, 0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran90Parser.ASSIGN, 0)
[docs]
def unitIdentifier(self):
return self.getTypedRuleContext(Fortran90Parser.UnitIdentifierContext,0)
[docs]
def FILE(self):
return self.getToken(Fortran90Parser.FILE, 0)
[docs]
def cExpression(self):
return self.getTypedRuleContext(Fortran90Parser.CExpressionContext,0)
[docs]
def ERR(self):
return self.getToken(Fortran90Parser.ERR, 0)
[docs]
def lblRef(self):
return self.getTypedRuleContext(Fortran90Parser.LblRefContext,0)
[docs]
def IOSTAT(self):
return self.getToken(Fortran90Parser.IOSTAT, 0)
[docs]
def scalarVariable(self):
return self.getTypedRuleContext(Fortran90Parser.ScalarVariableContext,0)
[docs]
def EXIST(self):
return self.getToken(Fortran90Parser.EXIST, 0)
[docs]
def OPENED(self):
return self.getToken(Fortran90Parser.OPENED, 0)
[docs]
def NUMBER(self):
return self.getToken(Fortran90Parser.NUMBER, 0)
[docs]
def NAMED(self):
return self.getToken(Fortran90Parser.NAMED, 0)
[docs]
def NAME(self):
return self.getToken(Fortran90Parser.NAME, 0)
[docs]
def ACCESS(self):
return self.getToken(Fortran90Parser.ACCESS, 0)
[docs]
def SEQUENTIAL(self):
return self.getToken(Fortran90Parser.SEQUENTIAL, 0)
[docs]
def DIRECT(self):
return self.getToken(Fortran90Parser.DIRECT, 0)
[docs]
def FORM(self):
return self.getToken(Fortran90Parser.FORM, 0)
[docs]
def FORMATTED(self):
return self.getToken(Fortran90Parser.FORMATTED, 0)
[docs]
def UNFORMATTED(self):
return self.getToken(Fortran90Parser.UNFORMATTED, 0)
[docs]
def RECL(self):
return self.getToken(Fortran90Parser.RECL, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,0)
[docs]
def NEXTREC(self):
return self.getToken(Fortran90Parser.NEXTREC, 0)
[docs]
def BLANK(self):
return self.getToken(Fortran90Parser.BLANK, 0)
[docs]
def POSITION(self):
return self.getToken(Fortran90Parser.POSITION, 0)
[docs]
def ACTION(self):
return self.getToken(Fortran90Parser.ACTION, 0)
[docs]
def READ(self):
return self.getToken(Fortran90Parser.READ, 0)
[docs]
def WRITE(self):
return self.getToken(Fortran90Parser.WRITE, 0)
[docs]
def READWRITE(self):
return self.getToken(Fortran90Parser.READWRITE, 0)
[docs]
def DELIM(self):
return self.getToken(Fortran90Parser.DELIM, 0)
[docs]
def PAD(self):
return self.getToken(Fortran90Parser.PAD, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_inquireSpec
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterInquireSpec" ):
listener.enterInquireSpec(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitInquireSpec" ):
listener.exitInquireSpec(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitInquireSpec" ):
return visitor.visitInquireSpec(self)
else:
return visitor.visitChildren(self)
[docs]
def inquireSpec(self):
localctx = Fortran90Parser.InquireSpecContext(self, self._ctx, self.state)
self.enterRule(localctx, 532, self.RULE_inquireSpec)
try:
self.state = 2989
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.UNIT]:
self.enterOuterAlt(localctx, 1)
self.state = 2914
self.match(Fortran90Parser.UNIT)
self.state = 2915
self.match(Fortran90Parser.ASSIGN)
self.state = 2916
self.unitIdentifier()
pass
elif token in [Fortran90Parser.FILE]:
self.enterOuterAlt(localctx, 2)
self.state = 2917
self.match(Fortran90Parser.FILE)
self.state = 2918
self.match(Fortran90Parser.ASSIGN)
self.state = 2919
self.cExpression()
pass
elif token in [Fortran90Parser.ERR]:
self.enterOuterAlt(localctx, 3)
self.state = 2920
self.match(Fortran90Parser.ERR)
self.state = 2921
self.match(Fortran90Parser.ASSIGN)
self.state = 2922
self.lblRef()
pass
elif token in [Fortran90Parser.IOSTAT]:
self.enterOuterAlt(localctx, 4)
self.state = 2923
self.match(Fortran90Parser.IOSTAT)
self.state = 2924
self.match(Fortran90Parser.ASSIGN)
self.state = 2925
self.scalarVariable()
pass
elif token in [Fortran90Parser.EXIST]:
self.enterOuterAlt(localctx, 5)
self.state = 2926
self.match(Fortran90Parser.EXIST)
self.state = 2927
self.match(Fortran90Parser.ASSIGN)
self.state = 2928
self.scalarVariable()
pass
elif token in [Fortran90Parser.OPENED]:
self.enterOuterAlt(localctx, 6)
self.state = 2929
self.match(Fortran90Parser.OPENED)
self.state = 2930
self.match(Fortran90Parser.ASSIGN)
self.state = 2931
self.scalarVariable()
pass
elif token in [Fortran90Parser.NUMBER]:
self.enterOuterAlt(localctx, 7)
self.state = 2932
self.match(Fortran90Parser.NUMBER)
self.state = 2933
self.match(Fortran90Parser.ASSIGN)
self.state = 2934
self.scalarVariable()
pass
elif token in [Fortran90Parser.NAMED]:
self.enterOuterAlt(localctx, 8)
self.state = 2935
self.match(Fortran90Parser.NAMED)
self.state = 2936
self.match(Fortran90Parser.ASSIGN)
self.state = 2937
self.scalarVariable()
pass
elif token in [Fortran90Parser.NAME]:
self.enterOuterAlt(localctx, 9)
self.state = 2938
self.match(Fortran90Parser.NAME)
self.state = 2939
self.match(Fortran90Parser.ASSIGN)
self.state = 2940
self.scalarVariable()
pass
elif token in [Fortran90Parser.ACCESS]:
self.enterOuterAlt(localctx, 10)
self.state = 2941
self.match(Fortran90Parser.ACCESS)
self.state = 2942
self.match(Fortran90Parser.ASSIGN)
self.state = 2943
self.scalarVariable()
pass
elif token in [Fortran90Parser.SEQUENTIAL]:
self.enterOuterAlt(localctx, 11)
self.state = 2944
self.match(Fortran90Parser.SEQUENTIAL)
self.state = 2945
self.match(Fortran90Parser.ASSIGN)
self.state = 2946
self.scalarVariable()
pass
elif token in [Fortran90Parser.DIRECT]:
self.enterOuterAlt(localctx, 12)
self.state = 2947
self.match(Fortran90Parser.DIRECT)
self.state = 2948
self.match(Fortran90Parser.ASSIGN)
self.state = 2949
self.scalarVariable()
pass
elif token in [Fortran90Parser.FORM]:
self.enterOuterAlt(localctx, 13)
self.state = 2950
self.match(Fortran90Parser.FORM)
self.state = 2951
self.match(Fortran90Parser.ASSIGN)
self.state = 2952
self.scalarVariable()
pass
elif token in [Fortran90Parser.FORMATTED]:
self.enterOuterAlt(localctx, 14)
self.state = 2953
self.match(Fortran90Parser.FORMATTED)
self.state = 2954
self.match(Fortran90Parser.ASSIGN)
self.state = 2955
self.scalarVariable()
pass
elif token in [Fortran90Parser.UNFORMATTED]:
self.enterOuterAlt(localctx, 15)
self.state = 2956
self.match(Fortran90Parser.UNFORMATTED)
self.state = 2957
self.match(Fortran90Parser.ASSIGN)
self.state = 2958
self.scalarVariable()
pass
elif token in [Fortran90Parser.RECL]:
self.enterOuterAlt(localctx, 16)
self.state = 2959
self.match(Fortran90Parser.RECL)
self.state = 2960
self.match(Fortran90Parser.ASSIGN)
self.state = 2961
self.expression(0)
pass
elif token in [Fortran90Parser.NEXTREC]:
self.enterOuterAlt(localctx, 17)
self.state = 2962
self.match(Fortran90Parser.NEXTREC)
self.state = 2963
self.match(Fortran90Parser.ASSIGN)
self.state = 2964
self.scalarVariable()
pass
elif token in [Fortran90Parser.BLANK]:
self.enterOuterAlt(localctx, 18)
self.state = 2965
self.match(Fortran90Parser.BLANK)
self.state = 2966
self.match(Fortran90Parser.ASSIGN)
self.state = 2967
self.scalarVariable()
pass
elif token in [Fortran90Parser.POSITION]:
self.enterOuterAlt(localctx, 19)
self.state = 2968
self.match(Fortran90Parser.POSITION)
self.state = 2969
self.match(Fortran90Parser.ASSIGN)
self.state = 2970
self.scalarVariable()
pass
elif token in [Fortran90Parser.ACTION]:
self.enterOuterAlt(localctx, 20)
self.state = 2971
self.match(Fortran90Parser.ACTION)
self.state = 2972
self.match(Fortran90Parser.ASSIGN)
self.state = 2973
self.scalarVariable()
pass
elif token in [Fortran90Parser.READ]:
self.enterOuterAlt(localctx, 21)
self.state = 2974
self.match(Fortran90Parser.READ)
self.state = 2975
self.match(Fortran90Parser.ASSIGN)
self.state = 2976
self.scalarVariable()
pass
elif token in [Fortran90Parser.WRITE]:
self.enterOuterAlt(localctx, 22)
self.state = 2977
self.match(Fortran90Parser.WRITE)
self.state = 2978
self.match(Fortran90Parser.ASSIGN)
self.state = 2979
self.scalarVariable()
pass
elif token in [Fortran90Parser.READWRITE]:
self.enterOuterAlt(localctx, 23)
self.state = 2980
self.match(Fortran90Parser.READWRITE)
self.state = 2981
self.match(Fortran90Parser.ASSIGN)
self.state = 2982
self.scalarVariable()
pass
elif token in [Fortran90Parser.DELIM]:
self.enterOuterAlt(localctx, 24)
self.state = 2983
self.match(Fortran90Parser.DELIM)
self.state = 2984
self.match(Fortran90Parser.ASSIGN)
self.state = 2985
self.scalarVariable()
pass
elif token in [Fortran90Parser.PAD]:
self.enterOuterAlt(localctx, 25)
self.state = 2986
self.match(Fortran90Parser.PAD)
self.state = 2987
self.match(Fortran90Parser.ASSIGN)
self.state = 2988
self.scalarVariable()
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 AssignedGotoStmtContext(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(Fortran90Parser.VariableNameContext,0)
[docs]
def GOTO(self):
return self.getToken(Fortran90Parser.GOTO, 0)
[docs]
def GO(self):
return self.getToken(Fortran90Parser.GO, 0)
[docs]
def TO(self):
return self.getToken(Fortran90Parser.TO, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def lblRefList(self):
return self.getTypedRuleContext(Fortran90Parser.LblRefListContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def variableComma(self):
return self.getTypedRuleContext(Fortran90Parser.VariableCommaContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_assignedGotoStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAssignedGotoStmt" ):
listener.enterAssignedGotoStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAssignedGotoStmt" ):
listener.exitAssignedGotoStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAssignedGotoStmt" ):
return visitor.visitAssignedGotoStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def assignedGotoStmt(self):
localctx = Fortran90Parser.AssignedGotoStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 534, self.RULE_assignedGotoStmt)
try:
self.state = 3017
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,245,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2994
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.GOTO]:
self.state = 2991
self.match(Fortran90Parser.GOTO)
pass
elif token in [Fortran90Parser.GO]:
self.state = 2992
self.match(Fortran90Parser.GO)
self.state = 2993
self.match(Fortran90Parser.TO)
pass
else:
raise NoViableAltException(self)
self.state = 2996
self.variableName()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 3000
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.GOTO]:
self.state = 2997
self.match(Fortran90Parser.GOTO)
pass
elif token in [Fortran90Parser.GO]:
self.state = 2998
self.match(Fortran90Parser.GO)
self.state = 2999
self.match(Fortran90Parser.TO)
pass
else:
raise NoViableAltException(self)
self.state = 3002
self.variableName()
self.state = 3003
self.match(Fortran90Parser.LPAREN)
self.state = 3004
self.lblRefList()
self.state = 3005
self.match(Fortran90Parser.RPAREN)
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 3010
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.GOTO]:
self.state = 3007
self.match(Fortran90Parser.GOTO)
pass
elif token in [Fortran90Parser.GO]:
self.state = 3008
self.match(Fortran90Parser.GO)
self.state = 3009
self.match(Fortran90Parser.TO)
pass
else:
raise NoViableAltException(self)
self.state = 3012
self.variableComma()
self.state = 3013
self.match(Fortran90Parser.LPAREN)
self.state = 3014
self.lblRefList()
self.state = 3015
self.match(Fortran90Parser.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 VariableCommaContext(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(Fortran90Parser.VariableNameContext,0)
[docs]
def COMMA(self):
return self.getToken(Fortran90Parser.COMMA, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_variableComma
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterVariableComma" ):
listener.enterVariableComma(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitVariableComma" ):
listener.exitVariableComma(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitVariableComma" ):
return visitor.visitVariableComma(self)
else:
return visitor.visitChildren(self)
[docs]
def variableComma(self):
localctx = Fortran90Parser.VariableCommaContext(self, self._ctx, self.state)
self.enterRule(localctx, 536, self.RULE_variableComma)
try:
self.enterOuterAlt(localctx, 1)
self.state = 3019
self.variableName()
self.state = 3020
self.match(Fortran90Parser.COMMA)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class GotoStmtContext(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(Fortran90Parser.LblRefContext,0)
[docs]
def GOTO(self):
return self.getToken(Fortran90Parser.GOTO, 0)
[docs]
def GO(self):
return self.getToken(Fortran90Parser.GO, 0)
[docs]
def TO(self):
return self.getToken(Fortran90Parser.TO, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_gotoStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterGotoStmt" ):
listener.enterGotoStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitGotoStmt" ):
listener.exitGotoStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitGotoStmt" ):
return visitor.visitGotoStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def gotoStmt(self):
localctx = Fortran90Parser.GotoStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 538, self.RULE_gotoStmt)
try:
self.enterOuterAlt(localctx, 1)
self.state = 3025
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.GOTO]:
self.state = 3022
self.match(Fortran90Parser.GOTO)
pass
elif token in [Fortran90Parser.GO]:
self.state = 3023
self.match(Fortran90Parser.GO)
self.state = 3024
self.match(Fortran90Parser.TO)
pass
else:
raise NoViableAltException(self)
self.state = 3027
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 ComputedGotoStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def GOTO(self):
return self.getToken(Fortran90Parser.GOTO, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def lblRefList(self):
return self.getTypedRuleContext(Fortran90Parser.LblRefListContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,0)
[docs]
def COMMA(self):
return self.getToken(Fortran90Parser.COMMA, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_computedGotoStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterComputedGotoStmt" ):
listener.enterComputedGotoStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitComputedGotoStmt" ):
listener.exitComputedGotoStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitComputedGotoStmt" ):
return visitor.visitComputedGotoStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def computedGotoStmt(self):
localctx = Fortran90Parser.ComputedGotoStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 540, self.RULE_computedGotoStmt)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 3029
self.match(Fortran90Parser.GOTO)
self.state = 3030
self.match(Fortran90Parser.LPAREN)
self.state = 3031
self.lblRefList()
self.state = 3032
self.match(Fortran90Parser.RPAREN)
self.state = 3034
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.COMMA:
self.state = 3033
self.match(Fortran90Parser.COMMA)
self.state = 3036
self.expression(0)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class LblRefListContext(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(Fortran90Parser.LblRefContext)
else:
return self.getTypedRuleContext(Fortran90Parser.LblRefContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_lblRefList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLblRefList" ):
listener.enterLblRefList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLblRefList" ):
listener.exitLblRefList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLblRefList" ):
return visitor.visitLblRefList(self)
else:
return visitor.visitChildren(self)
[docs]
def lblRefList(self):
localctx = Fortran90Parser.LblRefListContext(self, self._ctx, self.state)
self.enterRule(localctx, 542, self.RULE_lblRefList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 3038
self.lblRef()
self.state = 3043
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran90Parser.COMMA:
self.state = 3039
self.match(Fortran90Parser.COMMA)
self.state = 3040
self.lblRef()
self.state = 3045
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 EndfileStmtContext(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(Fortran90Parser.UnitIdentifierContext,0)
[docs]
def ENDFILE(self):
return self.getToken(Fortran90Parser.ENDFILE, 0)
[docs]
def END(self):
return self.getToken(Fortran90Parser.END, 0)
[docs]
def FILE(self):
return self.getToken(Fortran90Parser.FILE, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def positionSpecList(self):
return self.getTypedRuleContext(Fortran90Parser.PositionSpecListContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_endfileStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEndfileStmt" ):
listener.enterEndfileStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEndfileStmt" ):
listener.exitEndfileStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEndfileStmt" ):
return visitor.visitEndfileStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def endfileStmt(self):
localctx = Fortran90Parser.EndfileStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 544, self.RULE_endfileStmt)
try:
self.state = 3061
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,251,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 3049
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.ENDFILE]:
self.state = 3046
self.match(Fortran90Parser.ENDFILE)
pass
elif token in [Fortran90Parser.END]:
self.state = 3047
self.match(Fortran90Parser.END)
self.state = 3048
self.match(Fortran90Parser.FILE)
pass
else:
raise NoViableAltException(self)
self.state = 3051
self.unitIdentifier()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 3055
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.ENDFILE]:
self.state = 3052
self.match(Fortran90Parser.ENDFILE)
pass
elif token in [Fortran90Parser.END]:
self.state = 3053
self.match(Fortran90Parser.END)
self.state = 3054
self.match(Fortran90Parser.FILE)
pass
else:
raise NoViableAltException(self)
self.state = 3057
self.match(Fortran90Parser.LPAREN)
self.state = 3058
self.positionSpecList()
self.state = 3059
self.match(Fortran90Parser.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 ContinueStmtContext(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(Fortran90Parser.CONTINUE, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_continueStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterContinueStmt" ):
listener.enterContinueStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitContinueStmt" ):
listener.exitContinueStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitContinueStmt" ):
return visitor.visitContinueStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def continueStmt(self):
localctx = Fortran90Parser.ContinueStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 546, self.RULE_continueStmt)
try:
self.enterOuterAlt(localctx, 1)
self.state = 3063
self.match(Fortran90Parser.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 CloseStmtContext(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(Fortran90Parser.CLOSE, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def closeSpecList(self):
return self.getTypedRuleContext(Fortran90Parser.CloseSpecListContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_closeStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCloseStmt" ):
listener.enterCloseStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCloseStmt" ):
listener.exitCloseStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCloseStmt" ):
return visitor.visitCloseStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def closeStmt(self):
localctx = Fortran90Parser.CloseStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 548, self.RULE_closeStmt)
try:
self.enterOuterAlt(localctx, 1)
self.state = 3065
self.match(Fortran90Parser.CLOSE)
self.state = 3066
self.match(Fortran90Parser.LPAREN)
self.state = 3067
self.closeSpecList()
self.state = 3068
self.match(Fortran90Parser.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 CloseSpecListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def unitIdentifierComma(self):
return self.getTypedRuleContext(Fortran90Parser.UnitIdentifierCommaContext,0)
[docs]
def closeSpec(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.CloseSpecContext)
else:
return self.getTypedRuleContext(Fortran90Parser.CloseSpecContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_closeSpecList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCloseSpecList" ):
listener.enterCloseSpecList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCloseSpecList" ):
listener.exitCloseSpecList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCloseSpecList" ):
return visitor.visitCloseSpecList(self)
else:
return visitor.visitChildren(self)
[docs]
def closeSpecList(self):
localctx = Fortran90Parser.CloseSpecListContext(self, self._ctx, self.state)
self.enterRule(localctx, 550, self.RULE_closeSpecList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 3071
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.REAL or ((((_la - 84)) & ~0x3f) == 0 and ((1 << (_la - 84)) & ((1 << (Fortran90Parser.SIZE - 84)) | (1 << (Fortran90Parser.LPAREN - 84)) | (1 << (Fortran90Parser.MINUS - 84)) | (1 << (Fortran90Parser.PLUS - 84)))) != 0) or ((((_la - 177)) & ~0x3f) == 0 and ((1 << (_la - 177)) & ((1 << (Fortran90Parser.SCON - 177)) | (1 << (Fortran90Parser.ICON - 177)) | (1 << (Fortran90Parser.NAME - 177)) | (1 << (Fortran90Parser.STAR - 177)))) != 0):
self.state = 3070
self.unitIdentifierComma()
self.state = 3074
self._errHandler.sync(self)
_la = self._input.LA(1)
if ((((_la - 77)) & ~0x3f) == 0 and ((1 << (_la - 77)) & ((1 << (Fortran90Parser.UNIT - 77)) | (1 << (Fortran90Parser.ERR - 77)) | (1 << (Fortran90Parser.IOSTAT - 77)) | (1 << (Fortran90Parser.STATUS - 77)))) != 0):
self.state = 3073
self.closeSpec()
self.state = 3080
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran90Parser.COMMA:
self.state = 3076
self.match(Fortran90Parser.COMMA)
self.state = 3077
self.closeSpec()
self.state = 3082
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 CloseSpecContext(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(Fortran90Parser.UNIT, 0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran90Parser.ASSIGN, 0)
[docs]
def unitIdentifier(self):
return self.getTypedRuleContext(Fortran90Parser.UnitIdentifierContext,0)
[docs]
def ERR(self):
return self.getToken(Fortran90Parser.ERR, 0)
[docs]
def lblRef(self):
return self.getTypedRuleContext(Fortran90Parser.LblRefContext,0)
[docs]
def STATUS(self):
return self.getToken(Fortran90Parser.STATUS, 0)
[docs]
def cExpression(self):
return self.getTypedRuleContext(Fortran90Parser.CExpressionContext,0)
[docs]
def IOSTAT(self):
return self.getToken(Fortran90Parser.IOSTAT, 0)
[docs]
def scalarVariable(self):
return self.getTypedRuleContext(Fortran90Parser.ScalarVariableContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_closeSpec
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCloseSpec" ):
listener.enterCloseSpec(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCloseSpec" ):
listener.exitCloseSpec(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCloseSpec" ):
return visitor.visitCloseSpec(self)
else:
return visitor.visitChildren(self)
[docs]
def closeSpec(self):
localctx = Fortran90Parser.CloseSpecContext(self, self._ctx, self.state)
self.enterRule(localctx, 552, self.RULE_closeSpec)
try:
self.state = 3094
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.UNIT]:
self.enterOuterAlt(localctx, 1)
self.state = 3083
self.match(Fortran90Parser.UNIT)
self.state = 3084
self.match(Fortran90Parser.ASSIGN)
self.state = 3085
self.unitIdentifier()
pass
elif token in [Fortran90Parser.ERR]:
self.enterOuterAlt(localctx, 2)
self.state = 3086
self.match(Fortran90Parser.ERR)
self.state = 3087
self.match(Fortran90Parser.ASSIGN)
self.state = 3088
self.lblRef()
pass
elif token in [Fortran90Parser.STATUS]:
self.enterOuterAlt(localctx, 3)
self.state = 3089
self.match(Fortran90Parser.STATUS)
self.state = 3090
self.match(Fortran90Parser.ASSIGN)
self.state = 3091
self.cExpression()
pass
elif token in [Fortran90Parser.IOSTAT]:
self.enterOuterAlt(localctx, 4)
self.state = 3092
self.match(Fortran90Parser.IOSTAT)
self.state = 3093
self.scalarVariable()
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 CExpressionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def cPrimary(self):
return self.getTypedRuleContext(Fortran90Parser.CPrimaryContext,0)
[docs]
def cPrimaryConcatOp(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.CPrimaryConcatOpContext)
else:
return self.getTypedRuleContext(Fortran90Parser.CPrimaryConcatOpContext,i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_cExpression
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCExpression" ):
listener.enterCExpression(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCExpression" ):
listener.exitCExpression(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCExpression" ):
return visitor.visitCExpression(self)
else:
return visitor.visitChildren(self)
[docs]
def cExpression(self):
localctx = Fortran90Parser.CExpressionContext(self, self._ctx, self.state)
self.enterRule(localctx, 554, self.RULE_cExpression)
try:
self.enterOuterAlt(localctx, 1)
self.state = 3096
self.cPrimary()
self.state = 3100
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,256,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 3097
self.cPrimaryConcatOp()
self.state = 3102
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,256,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 CPrimaryContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def cOperand(self):
return self.getTypedRuleContext(Fortran90Parser.COperandContext,0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def cExpression(self):
return self.getTypedRuleContext(Fortran90Parser.CExpressionContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_cPrimary
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCPrimary" ):
listener.enterCPrimary(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCPrimary" ):
listener.exitCPrimary(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCPrimary" ):
return visitor.visitCPrimary(self)
else:
return visitor.visitChildren(self)
[docs]
def cPrimary(self):
localctx = Fortran90Parser.CPrimaryContext(self, self._ctx, self.state)
self.enterRule(localctx, 556, self.RULE_cPrimary)
try:
self.state = 3108
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.REAL, Fortran90Parser.SIZE, Fortran90Parser.SCON, Fortran90Parser.NAME]:
self.enterOuterAlt(localctx, 1)
self.state = 3103
self.cOperand()
pass
elif token in [Fortran90Parser.LPAREN]:
self.enterOuterAlt(localctx, 2)
self.state = 3104
self.match(Fortran90Parser.LPAREN)
self.state = 3105
self.cExpression()
self.state = 3106
self.match(Fortran90Parser.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 COperandContext(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(Fortran90Parser.SCON, 0)
[docs]
def nameDataRef(self):
return self.getTypedRuleContext(Fortran90Parser.NameDataRefContext,0)
[docs]
def functionReference(self):
return self.getTypedRuleContext(Fortran90Parser.FunctionReferenceContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_cOperand
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCOperand" ):
listener.enterCOperand(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCOperand" ):
listener.exitCOperand(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCOperand" ):
return visitor.visitCOperand(self)
else:
return visitor.visitChildren(self)
[docs]
def cOperand(self):
localctx = Fortran90Parser.COperandContext(self, self._ctx, self.state)
self.enterRule(localctx, 558, self.RULE_cOperand)
try:
self.state = 3113
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,258,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 3110
self.match(Fortran90Parser.SCON)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 3111
self.nameDataRef()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 3112
self.functionReference()
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 CPrimaryConcatOpContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def cPrimary(self):
return self.getTypedRuleContext(Fortran90Parser.CPrimaryContext,0)
[docs]
def DIV(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.DIV)
else:
return self.getToken(Fortran90Parser.DIV, i)
[docs]
def SPOFF(self):
return self.getToken(Fortran90Parser.SPOFF, 0)
[docs]
def SPON(self):
return self.getToken(Fortran90Parser.SPON, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_cPrimaryConcatOp
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCPrimaryConcatOp" ):
listener.enterCPrimaryConcatOp(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCPrimaryConcatOp" ):
listener.exitCPrimaryConcatOp(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCPrimaryConcatOp" ):
return visitor.visitCPrimaryConcatOp(self)
else:
return visitor.visitChildren(self)
[docs]
def cPrimaryConcatOp(self):
localctx = Fortran90Parser.CPrimaryConcatOpContext(self, self._ctx, self.state)
self.enterRule(localctx, 560, self.RULE_cPrimaryConcatOp)
try:
self.enterOuterAlt(localctx, 1)
self.state = 3115
self.cPrimary()
self.state = 3116
self.match(Fortran90Parser.DIV)
self.state = 3117
self.match(Fortran90Parser.SPOFF)
self.state = 3118
self.match(Fortran90Parser.DIV)
self.state = 3119
self.match(Fortran90Parser.SPON)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class CallStmtContext(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(Fortran90Parser.CALL, 0)
[docs]
def subroutineNameUse(self):
return self.getTypedRuleContext(Fortran90Parser.SubroutineNameUseContext,0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def subroutineArgList(self):
return self.getTypedRuleContext(Fortran90Parser.SubroutineArgListContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_callStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCallStmt" ):
listener.enterCallStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCallStmt" ):
listener.exitCallStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCallStmt" ):
return visitor.visitCallStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def callStmt(self):
localctx = Fortran90Parser.CallStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 562, self.RULE_callStmt)
try:
self.state = 3129
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,259,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 3121
self.match(Fortran90Parser.CALL)
self.state = 3122
self.subroutineNameUse()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 3123
self.match(Fortran90Parser.CALL)
self.state = 3124
self.subroutineNameUse()
self.state = 3125
self.match(Fortran90Parser.LPAREN)
self.state = 3126
self.subroutineArgList()
self.state = 3127
self.match(Fortran90Parser.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 SubroutineNameUseContext(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(Fortran90Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_subroutineNameUse
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSubroutineNameUse" ):
listener.enterSubroutineNameUse(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSubroutineNameUse" ):
listener.exitSubroutineNameUse(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSubroutineNameUse" ):
return visitor.visitSubroutineNameUse(self)
else:
return visitor.visitChildren(self)
[docs]
def subroutineNameUse(self):
localctx = Fortran90Parser.SubroutineNameUseContext(self, self._ctx, self.state)
self.enterRule(localctx, 564, self.RULE_subroutineNameUse)
try:
self.enterOuterAlt(localctx, 1)
self.state = 3131
self.match(Fortran90Parser.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 SubroutineArgListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def subroutineArg(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.SubroutineArgContext)
else:
return self.getTypedRuleContext(Fortran90Parser.SubroutineArgContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_subroutineArgList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSubroutineArgList" ):
listener.enterSubroutineArgList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSubroutineArgList" ):
listener.exitSubroutineArgList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSubroutineArgList" ):
return visitor.visitSubroutineArgList(self)
else:
return visitor.visitChildren(self)
[docs]
def subroutineArgList(self):
localctx = Fortran90Parser.SubroutineArgListContext(self, self._ctx, self.state)
self.enterRule(localctx, 566, self.RULE_subroutineArgList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 3134
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.DOP or _la==Fortran90Parser.REAL or ((((_la - 84)) & ~0x3f) == 0 and ((1 << (_la - 84)) & ((1 << (Fortran90Parser.SIZE - 84)) | (1 << (Fortran90Parser.LPAREN - 84)) | (1 << (Fortran90Parser.MINUS - 84)) | (1 << (Fortran90Parser.PLUS - 84)) | (1 << (Fortran90Parser.LNOT - 84)))) != 0) or ((((_la - 149)) & ~0x3f) == 0 and ((1 << (_la - 149)) & ((1 << (Fortran90Parser.TRUE - 149)) | (1 << (Fortran90Parser.FALSE - 149)) | (1 << (Fortran90Parser.HOLLERITH - 149)) | (1 << (Fortran90Parser.OBRACKETSLASH - 149)) | (1 << (Fortran90Parser.SCON - 149)) | (1 << (Fortran90Parser.RDCON - 149)) | (1 << (Fortran90Parser.ICON - 149)) | (1 << (Fortran90Parser.NAME - 149)) | (1 << (Fortran90Parser.STAR - 149)))) != 0):
self.state = 3133
self.subroutineArg()
self.state = 3140
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran90Parser.COMMA:
self.state = 3136
self.match(Fortran90Parser.COMMA)
self.state = 3137
self.subroutineArg()
self.state = 3142
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 SubroutineArgContext(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(Fortran90Parser.ExpressionContext,0)
[docs]
def HOLLERITH(self):
return self.getToken(Fortran90Parser.HOLLERITH, 0)
[docs]
def STAR(self):
return self.getToken(Fortran90Parser.STAR, 0)
[docs]
def lblRef(self):
return self.getTypedRuleContext(Fortran90Parser.LblRefContext,0)
[docs]
def NAME(self):
return self.getToken(Fortran90Parser.NAME, 0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran90Parser.ASSIGN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_subroutineArg
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSubroutineArg" ):
listener.enterSubroutineArg(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSubroutineArg" ):
listener.exitSubroutineArg(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSubroutineArg" ):
return visitor.visitSubroutineArg(self)
else:
return visitor.visitChildren(self)
[docs]
def subroutineArg(self):
localctx = Fortran90Parser.SubroutineArgContext(self, self._ctx, self.state)
self.enterRule(localctx, 568, self.RULE_subroutineArg)
try:
self.state = 3157
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,262,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 3143
self.expression(0)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 3144
self.match(Fortran90Parser.HOLLERITH)
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 3145
self.match(Fortran90Parser.STAR)
self.state = 3146
self.lblRef()
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 3147
self.match(Fortran90Parser.NAME)
self.state = 3148
self.match(Fortran90Parser.ASSIGN)
self.state = 3149
self.expression(0)
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 3150
self.match(Fortran90Parser.NAME)
self.state = 3151
self.match(Fortran90Parser.ASSIGN)
self.state = 3152
self.match(Fortran90Parser.HOLLERITH)
pass
elif la_ == 6:
self.enterOuterAlt(localctx, 6)
self.state = 3153
self.match(Fortran90Parser.NAME)
self.state = 3154
self.match(Fortran90Parser.ASSIGN)
self.state = 3155
self.match(Fortran90Parser.STAR)
self.state = 3156
self.lblRef()
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 ArithmeticIfStmtContext(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(Fortran90Parser.IF, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def lblRef(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.LblRefContext)
else:
return self.getTypedRuleContext(Fortran90Parser.LblRefContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_arithmeticIfStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterArithmeticIfStmt" ):
listener.enterArithmeticIfStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitArithmeticIfStmt" ):
listener.exitArithmeticIfStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitArithmeticIfStmt" ):
return visitor.visitArithmeticIfStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def arithmeticIfStmt(self):
localctx = Fortran90Parser.ArithmeticIfStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 570, self.RULE_arithmeticIfStmt)
try:
self.enterOuterAlt(localctx, 1)
self.state = 3159
self.match(Fortran90Parser.IF)
self.state = 3160
self.match(Fortran90Parser.LPAREN)
self.state = 3161
self.expression(0)
self.state = 3162
self.match(Fortran90Parser.RPAREN)
self.state = 3163
self.lblRef()
self.state = 3164
self.match(Fortran90Parser.COMMA)
self.state = 3165
self.lblRef()
self.state = 3166
self.match(Fortran90Parser.COMMA)
self.state = 3167
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 LblRefContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def label(self):
return self.getTypedRuleContext(Fortran90Parser.LabelContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.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 = Fortran90Parser.LblRefContext(self, self._ctx, self.state)
self.enterRule(localctx, 572, self.RULE_lblRef)
try:
self.enterOuterAlt(localctx, 1)
self.state = 3169
self.label()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class LabelContext(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(Fortran90Parser.ICON, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_label
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLabel" ):
listener.enterLabel(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLabel" ):
listener.exitLabel(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLabel" ):
return visitor.visitLabel(self)
else:
return visitor.visitChildren(self)
[docs]
def label(self):
localctx = Fortran90Parser.LabelContext(self, self._ctx, self.state)
self.enterRule(localctx, 574, self.RULE_label)
try:
self.enterOuterAlt(localctx, 1)
self.state = 3171
self.match(Fortran90Parser.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 AssignmentStmtContext(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(Fortran90Parser.NAME, 0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran90Parser.ASSIGN, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,0)
[docs]
def label(self):
return self.getTypedRuleContext(Fortran90Parser.LabelContext,0)
[docs]
def sFExprListRef(self):
return self.getTypedRuleContext(Fortran90Parser.SFExprListRefContext,0)
[docs]
def substringRange(self):
return self.getTypedRuleContext(Fortran90Parser.SubstringRangeContext,0)
[docs]
def PCT(self):
return self.getToken(Fortran90Parser.PCT, 0)
[docs]
def nameDataRef(self):
return self.getTypedRuleContext(Fortran90Parser.NameDataRefContext,0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def sFDummyArgNameList(self):
return self.getTypedRuleContext(Fortran90Parser.SFDummyArgNameListContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_assignmentStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAssignmentStmt" ):
listener.enterAssignmentStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAssignmentStmt" ):
listener.exitAssignmentStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAssignmentStmt" ):
return visitor.visitAssignmentStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def assignmentStmt(self):
localctx = Fortran90Parser.AssignmentStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 576, self.RULE_assignmentStmt)
self._la = 0 # Token type
try:
self.state = 3203
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,267,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 3174
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.ICON:
self.state = 3173
self.label()
self.state = 3176
self.match(Fortran90Parser.NAME)
self.state = 3178
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,264,self._ctx)
if la_ == 1:
self.state = 3177
self.sFExprListRef()
self.state = 3181
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.LPAREN:
self.state = 3180
self.substringRange()
self.state = 3183
self.match(Fortran90Parser.ASSIGN)
self.state = 3184
self.expression(0)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 3185
self.match(Fortran90Parser.NAME)
self.state = 3187
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.LPAREN:
self.state = 3186
self.sFExprListRef()
self.state = 3189
self.match(Fortran90Parser.PCT)
self.state = 3190
self.nameDataRef()
self.state = 3191
self.match(Fortran90Parser.ASSIGN)
self.state = 3192
self.expression(0)
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 3194
self.match(Fortran90Parser.NAME)
self.state = 3195
self.match(Fortran90Parser.LPAREN)
self.state = 3196
self.sFDummyArgNameList()
self.state = 3197
self.match(Fortran90Parser.RPAREN)
self.state = 3198
self.match(Fortran90Parser.PCT)
self.state = 3199
self.nameDataRef()
self.state = 3200
self.match(Fortran90Parser.ASSIGN)
self.state = 3201
self.expression(0)
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 SFExprListRefContext(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(Fortran90Parser.LPAREN, 0)
[docs]
def sFExprList(self):
return self.getTypedRuleContext(Fortran90Parser.SFExprListContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def commaSectionSubscript(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.CommaSectionSubscriptContext)
else:
return self.getTypedRuleContext(Fortran90Parser.CommaSectionSubscriptContext,i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_sFExprListRef
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSFExprListRef" ):
listener.enterSFExprListRef(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSFExprListRef" ):
listener.exitSFExprListRef(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSFExprListRef" ):
return visitor.visitSFExprListRef(self)
else:
return visitor.visitChildren(self)
[docs]
def sFExprListRef(self):
localctx = Fortran90Parser.SFExprListRefContext(self, self._ctx, self.state)
self.enterRule(localctx, 578, self.RULE_sFExprListRef)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 3205
self.match(Fortran90Parser.LPAREN)
self.state = 3206
self.sFExprList()
self.state = 3210
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==Fortran90Parser.COMMA:
self.state = 3207
self.commaSectionSubscript()
self.state = 3212
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 3213
self.match(Fortran90Parser.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 SFExprListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def expression(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.ExpressionContext)
else:
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,i)
[docs]
def COLON(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COLON)
else:
return self.getToken(Fortran90Parser.COLON, i)
[docs]
def DOUBLECOLON(self):
return self.getToken(Fortran90Parser.DOUBLECOLON, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_sFExprList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSFExprList" ):
listener.enterSFExprList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSFExprList" ):
listener.exitSFExprList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSFExprList" ):
return visitor.visitSFExprList(self)
else:
return visitor.visitChildren(self)
[docs]
def sFExprList(self):
localctx = Fortran90Parser.SFExprListContext(self, self._ctx, self.state)
self.enterRule(localctx, 580, self.RULE_sFExprList)
self._la = 0 # Token type
try:
self.state = 3239
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,274,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 3215
self.expression(0)
self.state = 3217
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.COLON:
self.state = 3216
self.match(Fortran90Parser.COLON)
self.state = 3220
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.DOP or _la==Fortran90Parser.REAL or ((((_la - 84)) & ~0x3f) == 0 and ((1 << (_la - 84)) & ((1 << (Fortran90Parser.SIZE - 84)) | (1 << (Fortran90Parser.LPAREN - 84)) | (1 << (Fortran90Parser.MINUS - 84)) | (1 << (Fortran90Parser.PLUS - 84)) | (1 << (Fortran90Parser.LNOT - 84)))) != 0) or ((((_la - 149)) & ~0x3f) == 0 and ((1 << (_la - 149)) & ((1 << (Fortran90Parser.TRUE - 149)) | (1 << (Fortran90Parser.FALSE - 149)) | (1 << (Fortran90Parser.OBRACKETSLASH - 149)) | (1 << (Fortran90Parser.SCON - 149)) | (1 << (Fortran90Parser.RDCON - 149)) | (1 << (Fortran90Parser.ICON - 149)) | (1 << (Fortran90Parser.NAME - 149)))) != 0):
self.state = 3219
self.expression(0)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 3222
self.match(Fortran90Parser.COLON)
self.state = 3224
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.DOP or _la==Fortran90Parser.REAL or ((((_la - 84)) & ~0x3f) == 0 and ((1 << (_la - 84)) & ((1 << (Fortran90Parser.SIZE - 84)) | (1 << (Fortran90Parser.LPAREN - 84)) | (1 << (Fortran90Parser.MINUS - 84)) | (1 << (Fortran90Parser.PLUS - 84)) | (1 << (Fortran90Parser.LNOT - 84)))) != 0) or ((((_la - 149)) & ~0x3f) == 0 and ((1 << (_la - 149)) & ((1 << (Fortran90Parser.TRUE - 149)) | (1 << (Fortran90Parser.FALSE - 149)) | (1 << (Fortran90Parser.OBRACKETSLASH - 149)) | (1 << (Fortran90Parser.SCON - 149)) | (1 << (Fortran90Parser.RDCON - 149)) | (1 << (Fortran90Parser.ICON - 149)) | (1 << (Fortran90Parser.NAME - 149)))) != 0):
self.state = 3223
self.expression(0)
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 3227
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.DOP or _la==Fortran90Parser.REAL or ((((_la - 84)) & ~0x3f) == 0 and ((1 << (_la - 84)) & ((1 << (Fortran90Parser.SIZE - 84)) | (1 << (Fortran90Parser.LPAREN - 84)) | (1 << (Fortran90Parser.MINUS - 84)) | (1 << (Fortran90Parser.PLUS - 84)) | (1 << (Fortran90Parser.LNOT - 84)))) != 0) or ((((_la - 149)) & ~0x3f) == 0 and ((1 << (_la - 149)) & ((1 << (Fortran90Parser.TRUE - 149)) | (1 << (Fortran90Parser.FALSE - 149)) | (1 << (Fortran90Parser.OBRACKETSLASH - 149)) | (1 << (Fortran90Parser.SCON - 149)) | (1 << (Fortran90Parser.RDCON - 149)) | (1 << (Fortran90Parser.ICON - 149)) | (1 << (Fortran90Parser.NAME - 149)))) != 0):
self.state = 3226
self.expression(0)
self.state = 3229
self.match(Fortran90Parser.COLON)
self.state = 3230
self.expression(0)
self.state = 3231
self.match(Fortran90Parser.COLON)
self.state = 3232
self.expression(0)
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 3235
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.DOP or _la==Fortran90Parser.REAL or ((((_la - 84)) & ~0x3f) == 0 and ((1 << (_la - 84)) & ((1 << (Fortran90Parser.SIZE - 84)) | (1 << (Fortran90Parser.LPAREN - 84)) | (1 << (Fortran90Parser.MINUS - 84)) | (1 << (Fortran90Parser.PLUS - 84)) | (1 << (Fortran90Parser.LNOT - 84)))) != 0) or ((((_la - 149)) & ~0x3f) == 0 and ((1 << (_la - 149)) & ((1 << (Fortran90Parser.TRUE - 149)) | (1 << (Fortran90Parser.FALSE - 149)) | (1 << (Fortran90Parser.OBRACKETSLASH - 149)) | (1 << (Fortran90Parser.SCON - 149)) | (1 << (Fortran90Parser.RDCON - 149)) | (1 << (Fortran90Parser.ICON - 149)) | (1 << (Fortran90Parser.NAME - 149)))) != 0):
self.state = 3234
self.expression(0)
self.state = 3237
self.match(Fortran90Parser.DOUBLECOLON)
self.state = 3238
self.expression(0)
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 CommaSectionSubscriptContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def COMMA(self):
return self.getToken(Fortran90Parser.COMMA, 0)
[docs]
def sectionSubscript(self):
return self.getTypedRuleContext(Fortran90Parser.SectionSubscriptContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_commaSectionSubscript
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCommaSectionSubscript" ):
listener.enterCommaSectionSubscript(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCommaSectionSubscript" ):
listener.exitCommaSectionSubscript(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCommaSectionSubscript" ):
return visitor.visitCommaSectionSubscript(self)
else:
return visitor.visitChildren(self)
[docs]
def commaSectionSubscript(self):
localctx = Fortran90Parser.CommaSectionSubscriptContext(self, self._ctx, self.state)
self.enterRule(localctx, 582, self.RULE_commaSectionSubscript)
try:
self.enterOuterAlt(localctx, 1)
self.state = 3241
self.match(Fortran90Parser.COMMA)
self.state = 3242
self.sectionSubscript()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class AssignStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ASSIGNSTMT(self):
return self.getToken(Fortran90Parser.ASSIGNSTMT, 0)
[docs]
def lblRef(self):
return self.getTypedRuleContext(Fortran90Parser.LblRefContext,0)
[docs]
def TO(self):
return self.getToken(Fortran90Parser.TO, 0)
[docs]
def variableName(self):
return self.getTypedRuleContext(Fortran90Parser.VariableNameContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_assignStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAssignStmt" ):
listener.enterAssignStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAssignStmt" ):
listener.exitAssignStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAssignStmt" ):
return visitor.visitAssignStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def assignStmt(self):
localctx = Fortran90Parser.AssignStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 584, self.RULE_assignStmt)
try:
self.enterOuterAlt(localctx, 1)
self.state = 3244
self.match(Fortran90Parser.ASSIGNSTMT)
self.state = 3245
self.lblRef()
self.state = 3246
self.match(Fortran90Parser.TO)
self.state = 3247
self.variableName()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class BackspaceStmtContext(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(Fortran90Parser.BACKSPACE, 0)
[docs]
def unitIdentifier(self):
return self.getTypedRuleContext(Fortran90Parser.UnitIdentifierContext,0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def positionSpecList(self):
return self.getTypedRuleContext(Fortran90Parser.PositionSpecListContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_backspaceStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterBackspaceStmt" ):
listener.enterBackspaceStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitBackspaceStmt" ):
listener.exitBackspaceStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitBackspaceStmt" ):
return visitor.visitBackspaceStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def backspaceStmt(self):
localctx = Fortran90Parser.BackspaceStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 586, self.RULE_backspaceStmt)
try:
self.state = 3256
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,275,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 3249
self.match(Fortran90Parser.BACKSPACE)
self.state = 3250
self.unitIdentifier()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 3251
self.match(Fortran90Parser.BACKSPACE)
self.state = 3252
self.match(Fortran90Parser.LPAREN)
self.state = 3253
self.positionSpecList()
self.state = 3254
self.match(Fortran90Parser.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 UnitIdentifierContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def uFExpr(self):
return self.getTypedRuleContext(Fortran90Parser.UFExprContext,0)
[docs]
def STAR(self):
return self.getToken(Fortran90Parser.STAR, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.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 = Fortran90Parser.UnitIdentifierContext(self, self._ctx, self.state)
self.enterRule(localctx, 588, self.RULE_unitIdentifier)
try:
self.state = 3260
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.REAL, Fortran90Parser.SIZE, Fortran90Parser.LPAREN, Fortran90Parser.MINUS, Fortran90Parser.PLUS, Fortran90Parser.SCON, Fortran90Parser.ICON, Fortran90Parser.NAME]:
self.enterOuterAlt(localctx, 1)
self.state = 3258
self.uFExpr(0)
pass
elif token in [Fortran90Parser.STAR]:
self.enterOuterAlt(localctx, 2)
self.state = 3259
self.match(Fortran90Parser.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 PositionSpecListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def unitIdentifierComma(self):
return self.getTypedRuleContext(Fortran90Parser.UnitIdentifierCommaContext,0)
[docs]
def positionSpec(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.PositionSpecContext)
else:
return self.getTypedRuleContext(Fortran90Parser.PositionSpecContext,i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_positionSpecList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPositionSpecList" ):
listener.enterPositionSpecList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPositionSpecList" ):
listener.exitPositionSpecList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPositionSpecList" ):
return visitor.visitPositionSpecList(self)
else:
return visitor.visitChildren(self)
[docs]
def positionSpecList(self):
localctx = Fortran90Parser.PositionSpecListContext(self, self._ctx, self.state)
self.enterRule(localctx, 590, self.RULE_positionSpecList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 3263
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.REAL or ((((_la - 84)) & ~0x3f) == 0 and ((1 << (_la - 84)) & ((1 << (Fortran90Parser.SIZE - 84)) | (1 << (Fortran90Parser.LPAREN - 84)) | (1 << (Fortran90Parser.MINUS - 84)) | (1 << (Fortran90Parser.PLUS - 84)))) != 0) or ((((_la - 177)) & ~0x3f) == 0 and ((1 << (_la - 177)) & ((1 << (Fortran90Parser.SCON - 177)) | (1 << (Fortran90Parser.ICON - 177)) | (1 << (Fortran90Parser.NAME - 177)) | (1 << (Fortran90Parser.STAR - 177)))) != 0):
self.state = 3262
self.unitIdentifierComma()
self.state = 3266
self._errHandler.sync(self)
_la = self._input.LA(1)
while True:
self.state = 3265
self.positionSpec()
self.state = 3268
self._errHandler.sync(self)
_la = self._input.LA(1)
if not (((((_la - 77)) & ~0x3f) == 0 and ((1 << (_la - 77)) & ((1 << (Fortran90Parser.UNIT - 77)) | (1 << (Fortran90Parser.ERR - 77)) | (1 << (Fortran90Parser.IOSTAT - 77)))) != 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 UnitIdentifierCommaContext(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(Fortran90Parser.UnitIdentifierContext,0)
[docs]
def COMMA(self):
return self.getToken(Fortran90Parser.COMMA, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_unitIdentifierComma
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterUnitIdentifierComma" ):
listener.enterUnitIdentifierComma(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitUnitIdentifierComma" ):
listener.exitUnitIdentifierComma(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitUnitIdentifierComma" ):
return visitor.visitUnitIdentifierComma(self)
else:
return visitor.visitChildren(self)
[docs]
def unitIdentifierComma(self):
localctx = Fortran90Parser.UnitIdentifierCommaContext(self, self._ctx, self.state)
self.enterRule(localctx, 592, self.RULE_unitIdentifierComma)
try:
self.enterOuterAlt(localctx, 1)
self.state = 3270
self.unitIdentifier()
self.state = 3272
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,279,self._ctx)
if la_ == 1:
self.state = 3271
self.match(Fortran90Parser.COMMA)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class PositionSpecContext(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(Fortran90Parser.UNIT, 0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran90Parser.ASSIGN, 0)
[docs]
def unitIdentifier(self):
return self.getTypedRuleContext(Fortran90Parser.UnitIdentifierContext,0)
[docs]
def ERR(self):
return self.getToken(Fortran90Parser.ERR, 0)
[docs]
def lblRef(self):
return self.getTypedRuleContext(Fortran90Parser.LblRefContext,0)
[docs]
def IOSTAT(self):
return self.getToken(Fortran90Parser.IOSTAT, 0)
[docs]
def scalarVariable(self):
return self.getTypedRuleContext(Fortran90Parser.ScalarVariableContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_positionSpec
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPositionSpec" ):
listener.enterPositionSpec(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPositionSpec" ):
listener.exitPositionSpec(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPositionSpec" ):
return visitor.visitPositionSpec(self)
else:
return visitor.visitChildren(self)
[docs]
def positionSpec(self):
localctx = Fortran90Parser.PositionSpecContext(self, self._ctx, self.state)
self.enterRule(localctx, 594, self.RULE_positionSpec)
try:
self.state = 3283
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.UNIT]:
self.enterOuterAlt(localctx, 1)
self.state = 3274
self.match(Fortran90Parser.UNIT)
self.state = 3275
self.match(Fortran90Parser.ASSIGN)
self.state = 3276
self.unitIdentifier()
pass
elif token in [Fortran90Parser.ERR]:
self.enterOuterAlt(localctx, 2)
self.state = 3277
self.match(Fortran90Parser.ERR)
self.state = 3278
self.match(Fortran90Parser.ASSIGN)
self.state = 3279
self.lblRef()
pass
elif token in [Fortran90Parser.IOSTAT]:
self.enterOuterAlt(localctx, 3)
self.state = 3280
self.match(Fortran90Parser.IOSTAT)
self.state = 3281
self.match(Fortran90Parser.ASSIGN)
self.state = 3282
self.scalarVariable()
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 ScalarVariableContext(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(Fortran90Parser.VariableNameContext,0)
[docs]
def arrayElement(self):
return self.getTypedRuleContext(Fortran90Parser.ArrayElementContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_scalarVariable
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterScalarVariable" ):
listener.enterScalarVariable(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitScalarVariable" ):
listener.exitScalarVariable(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitScalarVariable" ):
return visitor.visitScalarVariable(self)
else:
return visitor.visitChildren(self)
[docs]
def scalarVariable(self):
localctx = Fortran90Parser.ScalarVariableContext(self, self._ctx, self.state)
self.enterRule(localctx, 596, self.RULE_scalarVariable)
try:
self.state = 3287
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,281,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 3285
self.variableName()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 3286
self.arrayElement()
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 UFExprContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def uFTerm(self):
return self.getTypedRuleContext(Fortran90Parser.UFTermContext,0)
[docs]
def PLUS(self):
return self.getToken(Fortran90Parser.PLUS, 0)
[docs]
def MINUS(self):
return self.getToken(Fortran90Parser.MINUS, 0)
[docs]
def uFExpr(self):
return self.getTypedRuleContext(Fortran90Parser.UFExprContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_uFExpr
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterUFExpr" ):
listener.enterUFExpr(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitUFExpr" ):
listener.exitUFExpr(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitUFExpr" ):
return visitor.visitUFExpr(self)
else:
return visitor.visitChildren(self)
[docs]
def uFExpr(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = Fortran90Parser.UFExprContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 598
self.enterRecursionRule(localctx, 598, self.RULE_uFExpr, _p)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 3293
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.REAL, Fortran90Parser.SIZE, Fortran90Parser.LPAREN, Fortran90Parser.SCON, Fortran90Parser.ICON, Fortran90Parser.NAME]:
self.state = 3290
self.uFTerm(0)
pass
elif token in [Fortran90Parser.MINUS, Fortran90Parser.PLUS]:
self.state = 3291
_la = self._input.LA(1)
if not(_la==Fortran90Parser.MINUS or _la==Fortran90Parser.PLUS):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 3292
self.uFTerm(0)
pass
else:
raise NoViableAltException(self)
self._ctx.stop = self._input.LT(-1)
self.state = 3300
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,283,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = Fortran90Parser.UFExprContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_uFExpr)
self.state = 3295
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 3296
_la = self._input.LA(1)
if not(_la==Fortran90Parser.MINUS or _la==Fortran90Parser.PLUS):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 3297
self.uFTerm(0)
self.state = 3302
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,283,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class UFTermContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def uFFactor(self):
return self.getTypedRuleContext(Fortran90Parser.UFFactorContext,0)
[docs]
def uFTerm(self):
return self.getTypedRuleContext(Fortran90Parser.UFTermContext,0)
[docs]
def STAR(self):
return self.getToken(Fortran90Parser.STAR, 0)
[docs]
def DIV(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.DIV)
else:
return self.getToken(Fortran90Parser.DIV, i)
[docs]
def uFPrimary(self):
return self.getTypedRuleContext(Fortran90Parser.UFPrimaryContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_uFTerm
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterUFTerm" ):
listener.enterUFTerm(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitUFTerm" ):
listener.exitUFTerm(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitUFTerm" ):
return visitor.visitUFTerm(self)
else:
return visitor.visitChildren(self)
[docs]
def uFTerm(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = Fortran90Parser.UFTermContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 600
self.enterRecursionRule(localctx, 600, self.RULE_uFTerm, _p)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 3304
self.uFFactor()
self._ctx.stop = self._input.LT(-1)
self.state = 3316
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,285,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
self.state = 3314
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,284,self._ctx)
if la_ == 1:
localctx = Fortran90Parser.UFTermContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_uFTerm)
self.state = 3306
if not self.precpred(self._ctx, 2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
self.state = 3307
_la = self._input.LA(1)
if not(_la==Fortran90Parser.DIV or _la==Fortran90Parser.STAR):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 3308
self.uFFactor()
pass
elif la_ == 2:
localctx = Fortran90Parser.UFTermContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_uFTerm)
self.state = 3309
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 3310
self.match(Fortran90Parser.DIV)
self.state = 3311
self.match(Fortran90Parser.DIV)
self.state = 3313
self.uFPrimary()
pass
self.state = 3318
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,285,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class UFFactorContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def uFPrimary(self):
return self.getTypedRuleContext(Fortran90Parser.UFPrimaryContext,0)
[docs]
def POWER(self):
return self.getToken(Fortran90Parser.POWER, 0)
[docs]
def uFFactor(self):
return self.getTypedRuleContext(Fortran90Parser.UFFactorContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_uFFactor
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterUFFactor" ):
listener.enterUFFactor(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitUFFactor" ):
listener.exitUFFactor(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitUFFactor" ):
return visitor.visitUFFactor(self)
else:
return visitor.visitChildren(self)
[docs]
def uFFactor(self):
localctx = Fortran90Parser.UFFactorContext(self, self._ctx, self.state)
self.enterRule(localctx, 602, self.RULE_uFFactor)
try:
self.state = 3324
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,286,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 3319
self.uFPrimary()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 3320
self.uFPrimary()
self.state = 3321
self.match(Fortran90Parser.POWER)
self.state = 3322
self.uFFactor()
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 UFPrimaryContext(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(Fortran90Parser.ICON, 0)
[docs]
def SCON(self):
return self.getToken(Fortran90Parser.SCON, 0)
[docs]
def nameDataRef(self):
return self.getTypedRuleContext(Fortran90Parser.NameDataRefContext,0)
[docs]
def functionReference(self):
return self.getTypedRuleContext(Fortran90Parser.FunctionReferenceContext,0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def uFExpr(self):
return self.getTypedRuleContext(Fortran90Parser.UFExprContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_uFPrimary
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterUFPrimary" ):
listener.enterUFPrimary(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitUFPrimary" ):
listener.exitUFPrimary(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitUFPrimary" ):
return visitor.visitUFPrimary(self)
else:
return visitor.visitChildren(self)
[docs]
def uFPrimary(self):
localctx = Fortran90Parser.UFPrimaryContext(self, self._ctx, self.state)
self.enterRule(localctx, 604, self.RULE_uFPrimary)
try:
self.state = 3334
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,287,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 3326
self.match(Fortran90Parser.ICON)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 3327
self.match(Fortran90Parser.SCON)
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 3328
self.nameDataRef()
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 3329
self.functionReference()
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 3330
self.match(Fortran90Parser.LPAREN)
self.state = 3331
self.uFExpr(0)
self.state = 3332
self.match(Fortran90Parser.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 SubroutineSubprogramContext(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(Fortran90Parser.SUBROUTINE, 0)
[docs]
def subroutineName(self):
return self.getTypedRuleContext(Fortran90Parser.SubroutineNameContext,0)
[docs]
def subroutineRange(self):
return self.getTypedRuleContext(Fortran90Parser.SubroutineRangeContext,0)
[docs]
def RECURSIVE(self):
return self.getToken(Fortran90Parser.RECURSIVE, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.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 = Fortran90Parser.SubroutineSubprogramContext(self, self._ctx, self.state)
self.enterRule(localctx, 606, self.RULE_subroutineSubprogram)
try:
self.state = 3345
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.SUBROUTINE]:
self.enterOuterAlt(localctx, 1)
self.state = 3336
self.match(Fortran90Parser.SUBROUTINE)
self.state = 3337
self.subroutineName()
self.state = 3338
self.subroutineRange()
pass
elif token in [Fortran90Parser.RECURSIVE]:
self.enterOuterAlt(localctx, 2)
self.state = 3340
self.match(Fortran90Parser.RECURSIVE)
self.state = 3341
self.match(Fortran90Parser.SUBROUTINE)
self.state = 3342
self.subroutineName()
self.state = 3343
self.subroutineRange()
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 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(Fortran90Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.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 = Fortran90Parser.SubroutineNameContext(self, self._ctx, self.state)
self.enterRule(localctx, 608, self.RULE_subroutineName)
try:
self.enterOuterAlt(localctx, 1)
self.state = 3347
self.match(Fortran90Parser.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 SubroutineRangeContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def subroutineParList(self):
return self.getTypedRuleContext(Fortran90Parser.SubroutineParListContext,0)
[docs]
def endSubroutineStmt(self):
return self.getTypedRuleContext(Fortran90Parser.EndSubroutineStmtContext,0)
[docs]
def body(self):
return self.getTypedRuleContext(Fortran90Parser.BodyContext,0)
[docs]
def bodyPlusInternals(self):
return self.getTypedRuleContext(Fortran90Parser.BodyPlusInternalsContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_subroutineRange
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSubroutineRange" ):
listener.enterSubroutineRange(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSubroutineRange" ):
listener.exitSubroutineRange(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSubroutineRange" ):
return visitor.visitSubroutineRange(self)
else:
return visitor.visitChildren(self)
[docs]
def subroutineRange(self):
localctx = Fortran90Parser.SubroutineRangeContext(self, self._ctx, self.state)
self.enterRule(localctx, 610, self.RULE_subroutineRange)
try:
self.state = 3359
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,290,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 3349
self.subroutineParList()
self.state = 3351
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,289,self._ctx)
if la_ == 1:
self.state = 3350
self.body()
self.state = 3353
self.endSubroutineStmt()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 3355
self.subroutineParList()
self.state = 3356
self.bodyPlusInternals(0)
self.state = 3357
self.endSubroutineStmt()
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 IncludeStmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def INCLUDE(self):
return self.getToken(Fortran90Parser.INCLUDE, 0)
[docs]
def SCON(self):
return self.getToken(Fortran90Parser.SCON, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_includeStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIncludeStmt" ):
listener.enterIncludeStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIncludeStmt" ):
listener.exitIncludeStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIncludeStmt" ):
return visitor.visitIncludeStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def includeStmt(self):
localctx = Fortran90Parser.IncludeStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 612, self.RULE_includeStmt)
try:
self.enterOuterAlt(localctx, 1)
self.state = 3361
self.match(Fortran90Parser.INCLUDE)
self.state = 3362
self.match(Fortran90Parser.SCON)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ImplicitStmtContext(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(Fortran90Parser.IMPLICIT, 0)
[docs]
def implicitSpecList(self):
return self.getTypedRuleContext(Fortran90Parser.ImplicitSpecListContext,0)
[docs]
def NONE(self):
return self.getToken(Fortran90Parser.NONE, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_implicitStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterImplicitStmt" ):
listener.enterImplicitStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitImplicitStmt" ):
listener.exitImplicitStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitImplicitStmt" ):
return visitor.visitImplicitStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def implicitStmt(self):
localctx = Fortran90Parser.ImplicitStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 614, self.RULE_implicitStmt)
try:
self.state = 3368
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,291,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 3364
self.match(Fortran90Parser.IMPLICIT)
self.state = 3365
self.implicitSpecList()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 3366
self.match(Fortran90Parser.IMPLICIT)
self.state = 3367
self.match(Fortran90Parser.NONE)
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 ImplicitSpecListContext(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(Fortran90Parser.ImplicitSpecContext)
else:
return self.getTypedRuleContext(Fortran90Parser.ImplicitSpecContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_implicitSpecList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterImplicitSpecList" ):
listener.enterImplicitSpecList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitImplicitSpecList" ):
listener.exitImplicitSpecList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitImplicitSpecList" ):
return visitor.visitImplicitSpecList(self)
else:
return visitor.visitChildren(self)
[docs]
def implicitSpecList(self):
localctx = Fortran90Parser.ImplicitSpecListContext(self, self._ctx, self.state)
self.enterRule(localctx, 616, self.RULE_implicitSpecList)
try:
self.enterOuterAlt(localctx, 1)
self.state = 3370
self.implicitSpec()
self.state = 3375
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,292,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 3371
self.match(Fortran90Parser.COMMA)
self.state = 3372
self.implicitSpec()
self.state = 3377
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,292,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 ImplicitSpecContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def typeSpec(self):
return self.getTypedRuleContext(Fortran90Parser.TypeSpecContext,0)
[docs]
def implicitRanges(self):
return self.getTypedRuleContext(Fortran90Parser.ImplicitRangesContext,0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.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 = Fortran90Parser.ImplicitSpecContext(self, self._ctx, self.state)
self.enterRule(localctx, 618, self.RULE_implicitSpec)
try:
self.state = 3386
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,293,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 3378
self.typeSpec()
self.state = 3379
self.implicitRanges()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 3381
self.typeSpec()
self.state = 3382
self.match(Fortran90Parser.LPAREN)
self.state = 3383
self.implicitRanges()
self.state = 3384
self.match(Fortran90Parser.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 ImplicitRangesContext(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(Fortran90Parser.ImplicitRangeContext)
else:
return self.getTypedRuleContext(Fortran90Parser.ImplicitRangeContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_implicitRanges
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterImplicitRanges" ):
listener.enterImplicitRanges(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitImplicitRanges" ):
listener.exitImplicitRanges(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitImplicitRanges" ):
return visitor.visitImplicitRanges(self)
else:
return visitor.visitChildren(self)
[docs]
def implicitRanges(self):
localctx = Fortran90Parser.ImplicitRangesContext(self, self._ctx, self.state)
self.enterRule(localctx, 620, self.RULE_implicitRanges)
try:
self.enterOuterAlt(localctx, 1)
self.state = 3389
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,294,self._ctx)
if la_ == 1:
self.state = 3388
self.implicitRange()
self.state = 3395
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,295,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 3391
self.match(Fortran90Parser.COMMA)
self.state = 3392
self.implicitRange()
self.state = 3397
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,295,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 ImplicitRangeContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def NAME(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.NAME)
else:
return self.getToken(Fortran90Parser.NAME, i)
[docs]
def MINUS(self):
return self.getToken(Fortran90Parser.MINUS, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.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 = Fortran90Parser.ImplicitRangeContext(self, self._ctx, self.state)
self.enterRule(localctx, 622, self.RULE_implicitRange)
try:
self.enterOuterAlt(localctx, 1)
self.state = 3398
self.match(Fortran90Parser.NAME)
self.state = 3399
self.match(Fortran90Parser.MINUS)
self.state = 3400
self.match(Fortran90Parser.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 ExpressionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def level5Expr(self):
return self.getTypedRuleContext(Fortran90Parser.Level5ExprContext,0)
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,0)
[docs]
def definedBinaryOp(self):
return self.getTypedRuleContext(Fortran90Parser.DefinedBinaryOpContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.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, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = Fortran90Parser.ExpressionContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 624
self.enterRecursionRule(localctx, 624, self.RULE_expression, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 3403
self.level5Expr()
self._ctx.stop = self._input.LT(-1)
self.state = 3411
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,296,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = Fortran90Parser.ExpressionContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
self.state = 3405
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 3406
self.definedBinaryOp()
self.state = 3407
self.level5Expr()
self.state = 3413
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,296,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class DefinedBinaryOpContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def DOP(self):
return self.getToken(Fortran90Parser.DOP, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_definedBinaryOp
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDefinedBinaryOp" ):
listener.enterDefinedBinaryOp(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDefinedBinaryOp" ):
listener.exitDefinedBinaryOp(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDefinedBinaryOp" ):
return visitor.visitDefinedBinaryOp(self)
else:
return visitor.visitChildren(self)
[docs]
def definedBinaryOp(self):
localctx = Fortran90Parser.DefinedBinaryOpContext(self, self._ctx, self.state)
self.enterRule(localctx, 626, self.RULE_definedBinaryOp)
try:
self.enterOuterAlt(localctx, 1)
self.state = 3414
self.match(Fortran90Parser.DOP)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Level5ExprContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def equivOperand(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.EquivOperandContext)
else:
return self.getTypedRuleContext(Fortran90Parser.EquivOperandContext,i)
[docs]
def NEQV(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.NEQV)
else:
return self.getToken(Fortran90Parser.NEQV, i)
[docs]
def EQV(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.EQV)
else:
return self.getToken(Fortran90Parser.EQV, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_level5Expr
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLevel5Expr" ):
listener.enterLevel5Expr(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLevel5Expr" ):
listener.exitLevel5Expr(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLevel5Expr" ):
return visitor.visitLevel5Expr(self)
else:
return visitor.visitChildren(self)
[docs]
def level5Expr(self):
localctx = Fortran90Parser.Level5ExprContext(self, self._ctx, self.state)
self.enterRule(localctx, 628, self.RULE_level5Expr)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 3416
self.equivOperand()
self.state = 3421
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,297,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 3417
_la = self._input.LA(1)
if not(_la==Fortran90Parser.EQV or _la==Fortran90Parser.NEQV):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 3418
self.equivOperand()
self.state = 3423
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,297,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 EquivOperandContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def orOperand(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.OrOperandContext)
else:
return self.getTypedRuleContext(Fortran90Parser.OrOperandContext,i)
[docs]
def LOR(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.LOR)
else:
return self.getToken(Fortran90Parser.LOR, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_equivOperand
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEquivOperand" ):
listener.enterEquivOperand(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEquivOperand" ):
listener.exitEquivOperand(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEquivOperand" ):
return visitor.visitEquivOperand(self)
else:
return visitor.visitChildren(self)
[docs]
def equivOperand(self):
localctx = Fortran90Parser.EquivOperandContext(self, self._ctx, self.state)
self.enterRule(localctx, 630, self.RULE_equivOperand)
try:
self.enterOuterAlt(localctx, 1)
self.state = 3424
self.orOperand()
self.state = 3429
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,298,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 3425
self.match(Fortran90Parser.LOR)
self.state = 3426
self.orOperand()
self.state = 3431
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,298,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 OrOperandContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def andOperand(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.AndOperandContext)
else:
return self.getTypedRuleContext(Fortran90Parser.AndOperandContext,i)
[docs]
def LAND(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.LAND)
else:
return self.getToken(Fortran90Parser.LAND, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_orOperand
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterOrOperand" ):
listener.enterOrOperand(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitOrOperand" ):
listener.exitOrOperand(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitOrOperand" ):
return visitor.visitOrOperand(self)
else:
return visitor.visitChildren(self)
[docs]
def orOperand(self):
localctx = Fortran90Parser.OrOperandContext(self, self._ctx, self.state)
self.enterRule(localctx, 632, self.RULE_orOperand)
try:
self.enterOuterAlt(localctx, 1)
self.state = 3432
self.andOperand()
self.state = 3437
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,299,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 3433
self.match(Fortran90Parser.LAND)
self.state = 3434
self.andOperand()
self.state = 3439
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,299,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 AndOperandContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def level4Expr(self):
return self.getTypedRuleContext(Fortran90Parser.Level4ExprContext,0)
[docs]
def LNOT(self):
return self.getToken(Fortran90Parser.LNOT, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_andOperand
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAndOperand" ):
listener.enterAndOperand(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAndOperand" ):
listener.exitAndOperand(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAndOperand" ):
return visitor.visitAndOperand(self)
else:
return visitor.visitChildren(self)
[docs]
def andOperand(self):
localctx = Fortran90Parser.AndOperandContext(self, self._ctx, self.state)
self.enterRule(localctx, 634, self.RULE_andOperand)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 3441
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.LNOT:
self.state = 3440
self.match(Fortran90Parser.LNOT)
self.state = 3443
self.level4Expr()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class RelOpContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def LT(self):
return self.getToken(Fortran90Parser.LT, 0)
[docs]
def LE(self):
return self.getToken(Fortran90Parser.LE, 0)
[docs]
def EQ(self):
return self.getToken(Fortran90Parser.EQ, 0)
[docs]
def NE(self):
return self.getToken(Fortran90Parser.NE, 0)
[docs]
def GT(self):
return self.getToken(Fortran90Parser.GT, 0)
[docs]
def GE(self):
return self.getToken(Fortran90Parser.GE, 0)
[docs]
def OP(self):
return self.getToken(Fortran90Parser.OP, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_relOp
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterRelOp" ):
listener.enterRelOp(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitRelOp" ):
listener.exitRelOp(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitRelOp" ):
return visitor.visitRelOp(self)
else:
return visitor.visitChildren(self)
[docs]
def relOp(self):
localctx = Fortran90Parser.RelOpContext(self, self._ctx, self.state)
self.enterRule(localctx, 636, self.RULE_relOp)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 3445
_la = self._input.LA(1)
if not(_la==Fortran90Parser.OP or ((((_la - 143)) & ~0x3f) == 0 and ((1 << (_la - 143)) & ((1 << (Fortran90Parser.LT - 143)) | (1 << (Fortran90Parser.LE - 143)) | (1 << (Fortran90Parser.GT - 143)) | (1 << (Fortran90Parser.GE - 143)) | (1 << (Fortran90Parser.NE - 143)) | (1 << (Fortran90Parser.EQ - 143)))) != 0)):
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 Level4ExprContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def level3Expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.Level3ExprContext)
else:
return self.getTypedRuleContext(Fortran90Parser.Level3ExprContext,i)
[docs]
def relOp(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.RelOpContext)
else:
return self.getTypedRuleContext(Fortran90Parser.RelOpContext,i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_level4Expr
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLevel4Expr" ):
listener.enterLevel4Expr(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLevel4Expr" ):
listener.exitLevel4Expr(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLevel4Expr" ):
return visitor.visitLevel4Expr(self)
else:
return visitor.visitChildren(self)
[docs]
def level4Expr(self):
localctx = Fortran90Parser.Level4ExprContext(self, self._ctx, self.state)
self.enterRule(localctx, 638, self.RULE_level4Expr)
try:
self.enterOuterAlt(localctx, 1)
self.state = 3447
self.level3Expr()
self.state = 3453
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,301,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 3448
self.relOp()
self.state = 3449
self.level3Expr()
self.state = 3455
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,301,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 Level3ExprContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def level2Expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.Level2ExprContext)
else:
return self.getTypedRuleContext(Fortran90Parser.Level2ExprContext,i)
[docs]
def DIV(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.DIV)
else:
return self.getToken(Fortran90Parser.DIV, i)
[docs]
def SPOFF(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.SPOFF)
else:
return self.getToken(Fortran90Parser.SPOFF, i)
[docs]
def SPON(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.SPON)
else:
return self.getToken(Fortran90Parser.SPON, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_level3Expr
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLevel3Expr" ):
listener.enterLevel3Expr(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLevel3Expr" ):
listener.exitLevel3Expr(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLevel3Expr" ):
return visitor.visitLevel3Expr(self)
else:
return visitor.visitChildren(self)
[docs]
def level3Expr(self):
localctx = Fortran90Parser.Level3ExprContext(self, self._ctx, self.state)
self.enterRule(localctx, 640, self.RULE_level3Expr)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 3456
self.level2Expr()
self.state = 3468
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,304,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 3457
self.match(Fortran90Parser.DIV)
self.state = 3459
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.SPOFF:
self.state = 3458
self.match(Fortran90Parser.SPOFF)
self.state = 3461
self.match(Fortran90Parser.DIV)
self.state = 3463
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.SPON:
self.state = 3462
self.match(Fortran90Parser.SPON)
self.state = 3465
self.level2Expr()
self.state = 3470
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,304,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 Level2ExprContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def addOperand(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.AddOperandContext)
else:
return self.getTypedRuleContext(Fortran90Parser.AddOperandContext,i)
[docs]
def sign(self):
return self.getTypedRuleContext(Fortran90Parser.SignContext,0)
[docs]
def PLUS(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.PLUS)
else:
return self.getToken(Fortran90Parser.PLUS, i)
[docs]
def MINUS(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.MINUS)
else:
return self.getToken(Fortran90Parser.MINUS, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_level2Expr
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLevel2Expr" ):
listener.enterLevel2Expr(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLevel2Expr" ):
listener.exitLevel2Expr(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLevel2Expr" ):
return visitor.visitLevel2Expr(self)
else:
return visitor.visitChildren(self)
[docs]
def level2Expr(self):
localctx = Fortran90Parser.Level2ExprContext(self, self._ctx, self.state)
self.enterRule(localctx, 642, self.RULE_level2Expr)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 3472
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.MINUS or _la==Fortran90Parser.PLUS:
self.state = 3471
self.sign()
self.state = 3474
self.addOperand()
self.state = 3479
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,306,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 3475
_la = self._input.LA(1)
if not(_la==Fortran90Parser.MINUS or _la==Fortran90Parser.PLUS):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 3476
self.addOperand()
self.state = 3481
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,306,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 SignContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def PLUS(self):
return self.getToken(Fortran90Parser.PLUS, 0)
[docs]
def MINUS(self):
return self.getToken(Fortran90Parser.MINUS, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_sign
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSign" ):
listener.enterSign(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSign" ):
listener.exitSign(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSign" ):
return visitor.visitSign(self)
else:
return visitor.visitChildren(self)
[docs]
def sign(self):
localctx = Fortran90Parser.SignContext(self, self._ctx, self.state)
self.enterRule(localctx, 644, self.RULE_sign)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 3482
_la = self._input.LA(1)
if not(_la==Fortran90Parser.MINUS or _la==Fortran90Parser.PLUS):
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 AddOperandContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def multOperand(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.MultOperandContext)
else:
return self.getTypedRuleContext(Fortran90Parser.MultOperandContext,i)
[docs]
def STAR(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.STAR)
else:
return self.getToken(Fortran90Parser.STAR, i)
[docs]
def DIV(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.DIV)
else:
return self.getToken(Fortran90Parser.DIV, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_addOperand
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAddOperand" ):
listener.enterAddOperand(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAddOperand" ):
listener.exitAddOperand(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAddOperand" ):
return visitor.visitAddOperand(self)
else:
return visitor.visitChildren(self)
[docs]
def addOperand(self):
localctx = Fortran90Parser.AddOperandContext(self, self._ctx, self.state)
self.enterRule(localctx, 646, self.RULE_addOperand)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 3484
self.multOperand()
self.state = 3489
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,307,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 3485
_la = self._input.LA(1)
if not(_la==Fortran90Parser.DIV or _la==Fortran90Parser.STAR):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 3486
self.multOperand()
self.state = 3491
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,307,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 MultOperandContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def level1Expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.Level1ExprContext)
else:
return self.getTypedRuleContext(Fortran90Parser.Level1ExprContext,i)
[docs]
def POWER(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.POWER)
else:
return self.getToken(Fortran90Parser.POWER, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_multOperand
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterMultOperand" ):
listener.enterMultOperand(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitMultOperand" ):
listener.exitMultOperand(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitMultOperand" ):
return visitor.visitMultOperand(self)
else:
return visitor.visitChildren(self)
[docs]
def multOperand(self):
localctx = Fortran90Parser.MultOperandContext(self, self._ctx, self.state)
self.enterRule(localctx, 648, self.RULE_multOperand)
try:
self.enterOuterAlt(localctx, 1)
self.state = 3492
self.level1Expr()
self.state = 3497
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,308,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 3493
self.match(Fortran90Parser.POWER)
self.state = 3494
self.level1Expr()
self.state = 3499
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,308,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 Level1ExprContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def primary(self):
return self.getTypedRuleContext(Fortran90Parser.PrimaryContext,0)
[docs]
def definedUnaryOp(self):
return self.getTypedRuleContext(Fortran90Parser.DefinedUnaryOpContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_level1Expr
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLevel1Expr" ):
listener.enterLevel1Expr(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLevel1Expr" ):
listener.exitLevel1Expr(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLevel1Expr" ):
return visitor.visitLevel1Expr(self)
else:
return visitor.visitChildren(self)
[docs]
def level1Expr(self):
localctx = Fortran90Parser.Level1ExprContext(self, self._ctx, self.state)
self.enterRule(localctx, 650, self.RULE_level1Expr)
try:
self.state = 3504
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.REAL, Fortran90Parser.SIZE, Fortran90Parser.LPAREN, Fortran90Parser.TRUE, Fortran90Parser.FALSE, Fortran90Parser.OBRACKETSLASH, Fortran90Parser.SCON, Fortran90Parser.RDCON, Fortran90Parser.ICON, Fortran90Parser.NAME]:
self.enterOuterAlt(localctx, 1)
self.state = 3500
self.primary()
pass
elif token in [Fortran90Parser.DOP]:
self.enterOuterAlt(localctx, 2)
self.state = 3501
self.definedUnaryOp()
self.state = 3502
self.primary()
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 DefinedUnaryOpContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def DOP(self):
return self.getToken(Fortran90Parser.DOP, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_definedUnaryOp
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDefinedUnaryOp" ):
listener.enterDefinedUnaryOp(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDefinedUnaryOp" ):
listener.exitDefinedUnaryOp(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDefinedUnaryOp" ):
return visitor.visitDefinedUnaryOp(self)
else:
return visitor.visitChildren(self)
[docs]
def definedUnaryOp(self):
localctx = Fortran90Parser.DefinedUnaryOpContext(self, self._ctx, self.state)
self.enterRule(localctx, 652, self.RULE_definedUnaryOp)
try:
self.enterOuterAlt(localctx, 1)
self.state = 3506
self.match(Fortran90Parser.DOP)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class PrimaryContext(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(Fortran90Parser.UnsignedArithmeticConstantContext,0)
[docs]
def nameDataRef(self):
return self.getTypedRuleContext(Fortran90Parser.NameDataRefContext,0)
[docs]
def functionReference(self):
return self.getTypedRuleContext(Fortran90Parser.FunctionReferenceContext,0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def SCON(self):
return self.getToken(Fortran90Parser.SCON, 0)
[docs]
def logicalConstant(self):
return self.getTypedRuleContext(Fortran90Parser.LogicalConstantContext,0)
[docs]
def arrayConstructor(self):
return self.getTypedRuleContext(Fortran90Parser.ArrayConstructorContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_primary
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPrimary" ):
listener.enterPrimary(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPrimary" ):
listener.exitPrimary(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPrimary" ):
return visitor.visitPrimary(self)
else:
return visitor.visitChildren(self)
[docs]
def primary(self):
localctx = Fortran90Parser.PrimaryContext(self, self._ctx, self.state)
self.enterRule(localctx, 654, self.RULE_primary)
try:
self.state = 3518
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,310,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 3508
self.unsignedArithmeticConstant()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 3509
self.nameDataRef()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 3510
self.functionReference()
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 3511
self.match(Fortran90Parser.LPAREN)
self.state = 3512
self.expression(0)
self.state = 3513
self.match(Fortran90Parser.RPAREN)
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 3515
self.match(Fortran90Parser.SCON)
pass
elif la_ == 6:
self.enterOuterAlt(localctx, 6)
self.state = 3516
self.logicalConstant()
pass
elif la_ == 7:
self.enterOuterAlt(localctx, 7)
self.state = 3517
self.arrayConstructor()
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 ArrayConstructorContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def OBRACKETSLASH(self):
return self.getToken(Fortran90Parser.OBRACKETSLASH, 0)
[docs]
def acValueList(self):
return self.getTypedRuleContext(Fortran90Parser.AcValueListContext,0)
[docs]
def CBRACKETSLASH(self):
return self.getToken(Fortran90Parser.CBRACKETSLASH, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_arrayConstructor
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterArrayConstructor" ):
listener.enterArrayConstructor(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitArrayConstructor" ):
listener.exitArrayConstructor(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitArrayConstructor" ):
return visitor.visitArrayConstructor(self)
else:
return visitor.visitChildren(self)
[docs]
def arrayConstructor(self):
localctx = Fortran90Parser.ArrayConstructorContext(self, self._ctx, self.state)
self.enterRule(localctx, 656, self.RULE_arrayConstructor)
try:
self.enterOuterAlt(localctx, 1)
self.state = 3520
self.match(Fortran90Parser.OBRACKETSLASH)
self.state = 3521
self.acValueList()
self.state = 3522
self.match(Fortran90Parser.CBRACKETSLASH)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class AcValueListContext(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(Fortran90Parser.ExpressionContext,0)
[docs]
def acValueList1(self):
return self.getTypedRuleContext(Fortran90Parser.AcValueList1Context,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_acValueList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAcValueList" ):
listener.enterAcValueList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAcValueList" ):
listener.exitAcValueList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAcValueList" ):
return visitor.visitAcValueList(self)
else:
return visitor.visitChildren(self)
[docs]
def acValueList(self):
localctx = Fortran90Parser.AcValueListContext(self, self._ctx, self.state)
self.enterRule(localctx, 658, self.RULE_acValueList)
try:
self.state = 3526
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,311,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 3524
self.expression(0)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 3525
self.acValueList1(0)
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 AcValueList1Context(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def expression(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.ExpressionContext)
else:
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,i)
[docs]
def COMMA(self):
return self.getToken(Fortran90Parser.COMMA, 0)
[docs]
def acImpliedDo(self):
return self.getTypedRuleContext(Fortran90Parser.AcImpliedDoContext,0)
[docs]
def acValueList1(self):
return self.getTypedRuleContext(Fortran90Parser.AcValueList1Context,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_acValueList1
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAcValueList1" ):
listener.enterAcValueList1(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAcValueList1" ):
listener.exitAcValueList1(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAcValueList1" ):
return visitor.visitAcValueList1(self)
else:
return visitor.visitChildren(self)
[docs]
def acValueList1(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = Fortran90Parser.AcValueList1Context(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 660
self.enterRecursionRule(localctx, 660, self.RULE_acValueList1, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 3538
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,312,self._ctx)
if la_ == 1:
self.state = 3529
self.expression(0)
self.state = 3530
self.match(Fortran90Parser.COMMA)
self.state = 3531
self.expression(0)
pass
elif la_ == 2:
self.state = 3533
self.expression(0)
self.state = 3534
self.match(Fortran90Parser.COMMA)
self.state = 3535
self.acImpliedDo()
pass
elif la_ == 3:
self.state = 3537
self.acImpliedDo()
pass
self._ctx.stop = self._input.LT(-1)
self.state = 3548
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,314,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
self.state = 3546
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,313,self._ctx)
if la_ == 1:
localctx = Fortran90Parser.AcValueList1Context(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_acValueList1)
self.state = 3540
if not self.precpred(self._ctx, 2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
self.state = 3541
self.match(Fortran90Parser.COMMA)
self.state = 3542
self.expression(0)
pass
elif la_ == 2:
localctx = Fortran90Parser.AcValueList1Context(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_acValueList1)
self.state = 3543
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 3544
self.match(Fortran90Parser.COMMA)
self.state = 3545
self.acImpliedDo()
pass
self.state = 3550
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,314,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class AcImpliedDoContext(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(Fortran90Parser.LPAREN, 0)
[docs]
def expression(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.ExpressionContext)
else:
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def impliedDoVariable(self):
return self.getTypedRuleContext(Fortran90Parser.ImpliedDoVariableContext,0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran90Parser.ASSIGN, 0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def acImpliedDo(self):
return self.getTypedRuleContext(Fortran90Parser.AcImpliedDoContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_acImpliedDo
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAcImpliedDo" ):
listener.enterAcImpliedDo(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAcImpliedDo" ):
listener.exitAcImpliedDo(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAcImpliedDo" ):
return visitor.visitAcImpliedDo(self)
else:
return visitor.visitChildren(self)
[docs]
def acImpliedDo(self):
localctx = Fortran90Parser.AcImpliedDoContext(self, self._ctx, self.state)
self.enterRule(localctx, 662, self.RULE_acImpliedDo)
try:
self.state = 3595
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,315,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 3551
self.match(Fortran90Parser.LPAREN)
self.state = 3552
self.expression(0)
self.state = 3553
self.match(Fortran90Parser.COMMA)
self.state = 3554
self.impliedDoVariable()
self.state = 3555
self.match(Fortran90Parser.ASSIGN)
self.state = 3556
self.expression(0)
self.state = 3557
self.match(Fortran90Parser.COMMA)
self.state = 3558
self.expression(0)
self.state = 3559
self.match(Fortran90Parser.RPAREN)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 3561
self.match(Fortran90Parser.LPAREN)
self.state = 3562
self.expression(0)
self.state = 3563
self.match(Fortran90Parser.COMMA)
self.state = 3564
self.impliedDoVariable()
self.state = 3565
self.match(Fortran90Parser.ASSIGN)
self.state = 3566
self.expression(0)
self.state = 3567
self.match(Fortran90Parser.COMMA)
self.state = 3568
self.expression(0)
self.state = 3569
self.match(Fortran90Parser.COMMA)
self.state = 3570
self.expression(0)
self.state = 3571
self.match(Fortran90Parser.RPAREN)
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 3573
self.match(Fortran90Parser.LPAREN)
self.state = 3574
self.acImpliedDo()
self.state = 3575
self.match(Fortran90Parser.COMMA)
self.state = 3576
self.impliedDoVariable()
self.state = 3577
self.match(Fortran90Parser.ASSIGN)
self.state = 3578
self.expression(0)
self.state = 3579
self.match(Fortran90Parser.COMMA)
self.state = 3580
self.expression(0)
self.state = 3581
self.match(Fortran90Parser.RPAREN)
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 3583
self.match(Fortran90Parser.LPAREN)
self.state = 3584
self.acImpliedDo()
self.state = 3585
self.match(Fortran90Parser.COMMA)
self.state = 3586
self.impliedDoVariable()
self.state = 3587
self.match(Fortran90Parser.ASSIGN)
self.state = 3588
self.expression(0)
self.state = 3589
self.match(Fortran90Parser.COMMA)
self.state = 3590
self.expression(0)
self.state = 3591
self.match(Fortran90Parser.COMMA)
self.state = 3592
self.expression(0)
self.state = 3593
self.match(Fortran90Parser.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 FunctionReferenceContext(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(Fortran90Parser.NAME, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def functionArgList(self):
return self.getTypedRuleContext(Fortran90Parser.FunctionArgListContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_functionReference
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterFunctionReference" ):
listener.enterFunctionReference(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitFunctionReference" ):
listener.exitFunctionReference(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFunctionReference" ):
return visitor.visitFunctionReference(self)
else:
return visitor.visitChildren(self)
[docs]
def functionReference(self):
localctx = Fortran90Parser.FunctionReferenceContext(self, self._ctx, self.state)
self.enterRule(localctx, 664, self.RULE_functionReference)
try:
self.state = 3605
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,316,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 3597
self.match(Fortran90Parser.NAME)
self.state = 3598
self.match(Fortran90Parser.LPAREN)
self.state = 3599
self.match(Fortran90Parser.RPAREN)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 3600
self.match(Fortran90Parser.NAME)
self.state = 3601
self.match(Fortran90Parser.LPAREN)
self.state = 3602
self.functionArgList(0)
self.state = 3603
self.match(Fortran90Parser.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 FunctionArgListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def functionArg(self):
return self.getTypedRuleContext(Fortran90Parser.FunctionArgContext,0)
[docs]
def sectionSubscriptList(self):
return self.getTypedRuleContext(Fortran90Parser.SectionSubscriptListContext,0)
[docs]
def COMMA(self):
return self.getToken(Fortran90Parser.COMMA, 0)
[docs]
def functionArgList(self):
return self.getTypedRuleContext(Fortran90Parser.FunctionArgListContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_functionArgList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterFunctionArgList" ):
listener.enterFunctionArgList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitFunctionArgList" ):
listener.exitFunctionArgList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFunctionArgList" ):
return visitor.visitFunctionArgList(self)
else:
return visitor.visitChildren(self)
[docs]
def functionArgList(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = Fortran90Parser.FunctionArgListContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 666
self.enterRecursionRule(localctx, 666, self.RULE_functionArgList, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 3613
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,317,self._ctx)
if la_ == 1:
self.state = 3608
self.functionArg()
pass
elif la_ == 2:
self.state = 3609
self.sectionSubscriptList()
self.state = 3610
self.match(Fortran90Parser.COMMA)
self.state = 3611
self.functionArg()
pass
self._ctx.stop = self._input.LT(-1)
self.state = 3620
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,318,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = Fortran90Parser.FunctionArgListContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_functionArgList)
self.state = 3615
if not self.precpred(self._ctx, 2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
self.state = 3616
self.match(Fortran90Parser.COMMA)
self.state = 3617
self.functionArg()
self.state = 3622
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,318,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class FunctionArgContext(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(Fortran90Parser.NAME, 0)
[docs]
def ASSIGN(self):
return self.getToken(Fortran90Parser.ASSIGN, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_functionArg
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterFunctionArg" ):
listener.enterFunctionArg(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitFunctionArg" ):
listener.exitFunctionArg(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFunctionArg" ):
return visitor.visitFunctionArg(self)
else:
return visitor.visitChildren(self)
[docs]
def functionArg(self):
localctx = Fortran90Parser.FunctionArgContext(self, self._ctx, self.state)
self.enterRule(localctx, 668, self.RULE_functionArg)
try:
self.enterOuterAlt(localctx, 1)
self.state = 3623
self.match(Fortran90Parser.NAME)
self.state = 3624
self.match(Fortran90Parser.ASSIGN)
self.state = 3625
self.expression(0)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class NameDataRefContext(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(Fortran90Parser.NAME, 0)
[docs]
def REAL(self):
return self.getToken(Fortran90Parser.REAL, 0)
[docs]
def SIZE(self):
return self.getToken(Fortran90Parser.SIZE, 0)
[docs]
def complexDataRefTail(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.ComplexDataRefTailContext)
else:
return self.getTypedRuleContext(Fortran90Parser.ComplexDataRefTailContext,i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_nameDataRef
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterNameDataRef" ):
listener.enterNameDataRef(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitNameDataRef" ):
listener.exitNameDataRef(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNameDataRef" ):
return visitor.visitNameDataRef(self)
else:
return visitor.visitChildren(self)
[docs]
def nameDataRef(self):
localctx = Fortran90Parser.NameDataRefContext(self, self._ctx, self.state)
self.enterRule(localctx, 670, self.RULE_nameDataRef)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 3627
_la = self._input.LA(1)
if not(_la==Fortran90Parser.REAL or _la==Fortran90Parser.SIZE or _la==Fortran90Parser.NAME):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 3631
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,319,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 3628
self.complexDataRefTail()
self.state = 3633
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,319,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 ComplexDataRefTailContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def sectionSubscriptRef(self):
return self.getTypedRuleContext(Fortran90Parser.SectionSubscriptRefContext,0)
[docs]
def PCT(self):
return self.getToken(Fortran90Parser.PCT, 0)
[docs]
def NAME(self):
return self.getToken(Fortran90Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_complexDataRefTail
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterComplexDataRefTail" ):
listener.enterComplexDataRefTail(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitComplexDataRefTail" ):
listener.exitComplexDataRefTail(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitComplexDataRefTail" ):
return visitor.visitComplexDataRefTail(self)
else:
return visitor.visitChildren(self)
[docs]
def complexDataRefTail(self):
localctx = Fortran90Parser.ComplexDataRefTailContext(self, self._ctx, self.state)
self.enterRule(localctx, 672, self.RULE_complexDataRefTail)
try:
self.state = 3637
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.LPAREN]:
self.enterOuterAlt(localctx, 1)
self.state = 3634
self.sectionSubscriptRef()
pass
elif token in [Fortran90Parser.PCT]:
self.enterOuterAlt(localctx, 2)
self.state = 3635
self.match(Fortran90Parser.PCT)
self.state = 3636
self.match(Fortran90Parser.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 SectionSubscriptRefContext(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(Fortran90Parser.LPAREN, 0)
[docs]
def sectionSubscriptList(self):
return self.getTypedRuleContext(Fortran90Parser.SectionSubscriptListContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_sectionSubscriptRef
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSectionSubscriptRef" ):
listener.enterSectionSubscriptRef(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSectionSubscriptRef" ):
listener.exitSectionSubscriptRef(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSectionSubscriptRef" ):
return visitor.visitSectionSubscriptRef(self)
else:
return visitor.visitChildren(self)
[docs]
def sectionSubscriptRef(self):
localctx = Fortran90Parser.SectionSubscriptRefContext(self, self._ctx, self.state)
self.enterRule(localctx, 674, self.RULE_sectionSubscriptRef)
try:
self.enterOuterAlt(localctx, 1)
self.state = 3639
self.match(Fortran90Parser.LPAREN)
self.state = 3640
self.sectionSubscriptList()
self.state = 3641
self.match(Fortran90Parser.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 SectionSubscriptListContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def sectionSubscript(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.SectionSubscriptContext)
else:
return self.getTypedRuleContext(Fortran90Parser.SectionSubscriptContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COMMA)
else:
return self.getToken(Fortran90Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_sectionSubscriptList
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSectionSubscriptList" ):
listener.enterSectionSubscriptList(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSectionSubscriptList" ):
listener.exitSectionSubscriptList(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSectionSubscriptList" ):
return visitor.visitSectionSubscriptList(self)
else:
return visitor.visitChildren(self)
[docs]
def sectionSubscriptList(self):
localctx = Fortran90Parser.SectionSubscriptListContext(self, self._ctx, self.state)
self.enterRule(localctx, 676, self.RULE_sectionSubscriptList)
try:
self.enterOuterAlt(localctx, 1)
self.state = 3643
self.sectionSubscript()
self.state = 3648
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,321,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 3644
self.match(Fortran90Parser.COMMA)
self.state = 3645
self.sectionSubscript()
self.state = 3650
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,321,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 SectionSubscriptContext(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(Fortran90Parser.ExpressionContext,0)
[docs]
def subscriptTripletTail(self):
return self.getTypedRuleContext(Fortran90Parser.SubscriptTripletTailContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_sectionSubscript
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSectionSubscript" ):
listener.enterSectionSubscript(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSectionSubscript" ):
listener.exitSectionSubscript(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSectionSubscript" ):
return visitor.visitSectionSubscript(self)
else:
return visitor.visitChildren(self)
[docs]
def sectionSubscript(self):
localctx = Fortran90Parser.SectionSubscriptContext(self, self._ctx, self.state)
self.enterRule(localctx, 678, self.RULE_sectionSubscript)
self._la = 0 # Token type
try:
self.state = 3656
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.DOP, Fortran90Parser.REAL, Fortran90Parser.SIZE, Fortran90Parser.LPAREN, Fortran90Parser.MINUS, Fortran90Parser.PLUS, Fortran90Parser.LNOT, Fortran90Parser.TRUE, Fortran90Parser.FALSE, Fortran90Parser.OBRACKETSLASH, Fortran90Parser.SCON, Fortran90Parser.RDCON, Fortran90Parser.ICON, Fortran90Parser.NAME]:
self.enterOuterAlt(localctx, 1)
self.state = 3651
self.expression(0)
self.state = 3653
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.DOUBLECOLON or _la==Fortran90Parser.COLON:
self.state = 3652
self.subscriptTripletTail()
pass
elif token in [Fortran90Parser.DOUBLECOLON, Fortran90Parser.COLON]:
self.enterOuterAlt(localctx, 2)
self.state = 3655
self.subscriptTripletTail()
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 SubscriptTripletTailContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def COLON(self, i:int=None):
if i is None:
return self.getTokens(Fortran90Parser.COLON)
else:
return self.getToken(Fortran90Parser.COLON, i)
[docs]
def expression(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(Fortran90Parser.ExpressionContext)
else:
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,i)
[docs]
def DOUBLECOLON(self):
return self.getToken(Fortran90Parser.DOUBLECOLON, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_subscriptTripletTail
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSubscriptTripletTail" ):
listener.enterSubscriptTripletTail(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSubscriptTripletTail" ):
listener.exitSubscriptTripletTail(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSubscriptTripletTail" ):
return visitor.visitSubscriptTripletTail(self)
else:
return visitor.visitChildren(self)
[docs]
def subscriptTripletTail(self):
localctx = Fortran90Parser.SubscriptTripletTailContext(self, self._ctx, self.state)
self.enterRule(localctx, 680, self.RULE_subscriptTripletTail)
self._la = 0 # Token type
try:
self.state = 3669
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,325,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 3658
self.match(Fortran90Parser.COLON)
self.state = 3660
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.DOP or _la==Fortran90Parser.REAL or ((((_la - 84)) & ~0x3f) == 0 and ((1 << (_la - 84)) & ((1 << (Fortran90Parser.SIZE - 84)) | (1 << (Fortran90Parser.LPAREN - 84)) | (1 << (Fortran90Parser.MINUS - 84)) | (1 << (Fortran90Parser.PLUS - 84)) | (1 << (Fortran90Parser.LNOT - 84)))) != 0) or ((((_la - 149)) & ~0x3f) == 0 and ((1 << (_la - 149)) & ((1 << (Fortran90Parser.TRUE - 149)) | (1 << (Fortran90Parser.FALSE - 149)) | (1 << (Fortran90Parser.OBRACKETSLASH - 149)) | (1 << (Fortran90Parser.SCON - 149)) | (1 << (Fortran90Parser.RDCON - 149)) | (1 << (Fortran90Parser.ICON - 149)) | (1 << (Fortran90Parser.NAME - 149)))) != 0):
self.state = 3659
self.expression(0)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 3662
self.match(Fortran90Parser.COLON)
self.state = 3663
self.expression(0)
self.state = 3664
self.match(Fortran90Parser.COLON)
self.state = 3665
self.expression(0)
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 3667
self.match(Fortran90Parser.DOUBLECOLON)
self.state = 3668
self.expression(0)
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 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(Fortran90Parser.TRUE, 0)
[docs]
def FALSE(self):
return self.getToken(Fortran90Parser.FALSE, 0)
[docs]
def UNDERSCORE(self):
return self.getToken(Fortran90Parser.UNDERSCORE, 0)
[docs]
def kindParam(self):
return self.getTypedRuleContext(Fortran90Parser.KindParamContext,0)
[docs]
def DOT(self):
return self.getToken(Fortran90Parser.DOT, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.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 = Fortran90Parser.LogicalConstantContext(self, self._ctx, self.state)
self.enterRule(localctx, 682, self.RULE_logicalConstant)
self._la = 0 # Token type
try:
self.state = 3680
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,326,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 3671
_la = self._input.LA(1)
if not(_la==Fortran90Parser.TRUE or _la==Fortran90Parser.FALSE):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 3672
self.match(Fortran90Parser.TRUE)
self.state = 3673
self.match(Fortran90Parser.UNDERSCORE)
self.state = 3674
self.kindParam()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 3675
self.match(Fortran90Parser.FALSE)
self.state = 3676
self.match(Fortran90Parser.UNDERSCORE)
self.state = 3677
self.kindParam()
self.state = 3678
self.match(Fortran90Parser.DOT)
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 KindParamContext(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(Fortran90Parser.ICON, 0)
[docs]
def namedConstantUse(self):
return self.getTypedRuleContext(Fortran90Parser.NamedConstantUseContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_kindParam
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterKindParam" ):
listener.enterKindParam(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitKindParam" ):
listener.exitKindParam(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitKindParam" ):
return visitor.visitKindParam(self)
else:
return visitor.visitChildren(self)
[docs]
def kindParam(self):
localctx = Fortran90Parser.KindParamContext(self, self._ctx, self.state)
self.enterRule(localctx, 684, self.RULE_kindParam)
try:
self.state = 3684
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.ICON]:
self.enterOuterAlt(localctx, 1)
self.state = 3682
self.match(Fortran90Parser.ICON)
pass
elif token in [Fortran90Parser.NAME]:
self.enterOuterAlt(localctx, 2)
self.state = 3683
self.namedConstantUse()
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(Fortran90Parser.ICON, 0)
[docs]
def RDCON(self):
return self.getToken(Fortran90Parser.RDCON, 0)
[docs]
def complexConst(self):
return self.getTypedRuleContext(Fortran90Parser.ComplexConstContext,0)
[docs]
def UNDERSCORE(self):
return self.getToken(Fortran90Parser.UNDERSCORE, 0)
[docs]
def kindParam(self):
return self.getTypedRuleContext(Fortran90Parser.KindParamContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.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 = Fortran90Parser.UnsignedArithmeticConstantContext(self, self._ctx, self.state)
self.enterRule(localctx, 686, self.RULE_unsignedArithmeticConstant)
self._la = 0 # Token type
try:
self.state = 3694
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,328,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 3686
_la = self._input.LA(1)
if not(_la==Fortran90Parser.RDCON or _la==Fortran90Parser.ICON):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 3687
self.complexConst()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 3688
self.match(Fortran90Parser.ICON)
self.state = 3689
self.match(Fortran90Parser.UNDERSCORE)
self.state = 3690
self.kindParam()
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 3691
self.match(Fortran90Parser.RDCON)
self.state = 3692
self.match(Fortran90Parser.UNDERSCORE)
self.state = 3693
self.kindParam()
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 ComplexConstContext(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(Fortran90Parser.LPAREN, 0)
[docs]
def complexComponent(self):
return self.getTypedRuleContext(Fortran90Parser.ComplexComponentContext,0)
[docs]
def COMMA(self):
return self.getToken(Fortran90Parser.COMMA, 0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_complexConst
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterComplexConst" ):
listener.enterComplexConst(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitComplexConst" ):
listener.exitComplexConst(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitComplexConst" ):
return visitor.visitComplexConst(self)
else:
return visitor.visitChildren(self)
[docs]
def complexConst(self):
localctx = Fortran90Parser.ComplexConstContext(self, self._ctx, self.state)
self.enterRule(localctx, 688, self.RULE_complexConst)
try:
self.enterOuterAlt(localctx, 1)
self.state = 3696
self.match(Fortran90Parser.LPAREN)
self.state = 3697
self.complexComponent()
self.state = 3698
self.match(Fortran90Parser.COMMA)
self.state = 3699
self.match(Fortran90Parser.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 ComplexComponentContext(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(Fortran90Parser.ICON, 0)
[docs]
def PLUS(self):
return self.getToken(Fortran90Parser.PLUS, 0)
[docs]
def MINUS(self):
return self.getToken(Fortran90Parser.MINUS, 0)
[docs]
def RDCON(self):
return self.getToken(Fortran90Parser.RDCON, 0)
[docs]
def NAME(self):
return self.getToken(Fortran90Parser.NAME, 0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_complexComponent
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterComplexComponent" ):
listener.enterComplexComponent(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitComplexComponent" ):
listener.exitComplexComponent(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitComplexComponent" ):
return visitor.visitComplexComponent(self)
else:
return visitor.visitChildren(self)
[docs]
def complexComponent(self):
localctx = Fortran90Parser.ComplexComponentContext(self, self._ctx, self.state)
self.enterRule(localctx, 690, self.RULE_complexComponent)
self._la = 0 # Token type
try:
self.state = 3707
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [Fortran90Parser.MINUS, Fortran90Parser.PLUS, Fortran90Parser.ICON]:
self.enterOuterAlt(localctx, 1)
self.state = 3702
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==Fortran90Parser.MINUS or _la==Fortran90Parser.PLUS:
self.state = 3701
_la = self._input.LA(1)
if not(_la==Fortran90Parser.MINUS or _la==Fortran90Parser.PLUS):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 3704
self.match(Fortran90Parser.ICON)
pass
elif token in [Fortran90Parser.RDCON]:
self.enterOuterAlt(localctx, 2)
self.state = 3705
self.match(Fortran90Parser.RDCON)
pass
elif token in [Fortran90Parser.NAME]:
self.enterOuterAlt(localctx, 3)
self.state = 3706
self.match(Fortran90Parser.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 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(Fortran90Parser.ExpressionContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.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 = Fortran90Parser.ConstantExprContext(self, self._ctx, self.state)
self.enterRule(localctx, 692, self.RULE_constantExpr)
try:
self.enterOuterAlt(localctx, 1)
self.state = 3709
self.expression(0)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class IfStmtContext(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(Fortran90Parser.IF, 0)
[docs]
def LPAREN(self):
return self.getToken(Fortran90Parser.LPAREN, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(Fortran90Parser.ExpressionContext,0)
[docs]
def RPAREN(self):
return self.getToken(Fortran90Parser.RPAREN, 0)
[docs]
def actionStmt(self):
return self.getTypedRuleContext(Fortran90Parser.ActionStmtContext,0)
[docs]
def getRuleIndex(self):
return Fortran90Parser.RULE_ifStmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIfStmt" ):
listener.enterIfStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIfStmt" ):
listener.exitIfStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIfStmt" ):
return visitor.visitIfStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def ifStmt(self):
localctx = Fortran90Parser.IfStmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 694, self.RULE_ifStmt)
try:
self.enterOuterAlt(localctx, 1)
self.state = 3711
self.match(Fortran90Parser.IF)
self.state = 3712
self.match(Fortran90Parser.LPAREN)
self.state = 3713
self.expression(0)
self.state = 3714
self.match(Fortran90Parser.RPAREN)
self.state = 3715
self.actionStmt()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
if self._predicates == None:
self._predicates = dict()
self._predicates[6] = self.bodyPlusInternals_sempred
self._predicates[21] = self.blockDataBody_sempred
self._predicates[25] = self.fmtSpec_sempred
self._predicates[47] = self.namelistGroups_sempred
self._predicates[81] = self.comlist_sempred
self._predicates[87] = self.attrSpecSeq_sempred
self._predicates[93] = self.assumedShapeSpecList_sempred
self._predicates[101] = self.interfaceBlockBody_sempred
self._predicates[115] = self.subprogramInterfaceBody_sempred
self._predicates[120] = self.derivedTypeBody_sempred
self._predicates[151] = self.moduleBody_sempred
self._predicates[162] = self.elseWhere_sempred
self._predicates[165] = self.where_sempred
self._predicates[171] = self.selectCaseBody_sempred
self._predicates[210] = self.structureComponent_sempred
self._predicates[225] = self.pointerField_sempred
self._predicates[233] = self.allocateObject_sempred
self._predicates[237] = self.ioControlSpecList_sempred
self._predicates[253] = self.rdIoCtlSpecList_sempred
self._predicates[257] = self.outputItemList1_sempred
self._predicates[299] = self.uFExpr_sempred
self._predicates[300] = self.uFTerm_sempred
self._predicates[312] = self.expression_sempred
self._predicates[330] = self.acValueList1_sempred
self._predicates[333] = self.functionArgList_sempred
pred = self._predicates.get(ruleIndex, None)
if pred is None:
raise Exception("No predicate with index:" + str(ruleIndex))
else:
return pred(localctx, predIndex)
[docs]
def bodyPlusInternals_sempred(self, localctx:BodyPlusInternalsContext, predIndex:int):
if predIndex == 0:
return self.precpred(self._ctx, 1)
[docs]
def blockDataBody_sempred(self, localctx:BlockDataBodyContext, predIndex:int):
if predIndex == 1:
return self.precpred(self._ctx, 1)
[docs]
def fmtSpec_sempred(self, localctx:FmtSpecContext, predIndex:int):
if predIndex == 2:
return self.precpred(self._ctx, 5)
if predIndex == 3:
return self.precpred(self._ctx, 4)
if predIndex == 4:
return self.precpred(self._ctx, 3)
if predIndex == 5:
return self.precpred(self._ctx, 2)
if predIndex == 6:
return self.precpred(self._ctx, 1)
[docs]
def namelistGroups_sempred(self, localctx:NamelistGroupsContext, predIndex:int):
if predIndex == 7:
return self.precpred(self._ctx, 3)
if predIndex == 8:
return self.precpred(self._ctx, 2)
if predIndex == 9:
return self.precpred(self._ctx, 1)
[docs]
def comlist_sempred(self, localctx:ComlistContext, predIndex:int):
if predIndex == 10:
return self.precpred(self._ctx, 2)
if predIndex == 11:
return self.precpred(self._ctx, 1)
[docs]
def attrSpecSeq_sempred(self, localctx:AttrSpecSeqContext, predIndex:int):
if predIndex == 12:
return self.precpred(self._ctx, 1)
[docs]
def assumedShapeSpecList_sempred(self, localctx:AssumedShapeSpecListContext, predIndex:int):
if predIndex == 13:
return self.precpred(self._ctx, 1)
[docs]
def interfaceBlockBody_sempred(self, localctx:InterfaceBlockBodyContext, predIndex:int):
if predIndex == 14:
return self.precpred(self._ctx, 1)
[docs]
def subprogramInterfaceBody_sempred(self, localctx:SubprogramInterfaceBodyContext, predIndex:int):
if predIndex == 15:
return self.precpred(self._ctx, 1)
[docs]
def derivedTypeBody_sempred(self, localctx:DerivedTypeBodyContext, predIndex:int):
if predIndex == 16:
return self.precpred(self._ctx, 1)
[docs]
def moduleBody_sempred(self, localctx:ModuleBodyContext, predIndex:int):
if predIndex == 17:
return self.precpred(self._ctx, 2)
if predIndex == 18:
return self.precpred(self._ctx, 1)
[docs]
def elseWhere_sempred(self, localctx:ElseWhereContext, predIndex:int):
if predIndex == 19:
return self.precpred(self._ctx, 1)
[docs]
def where_sempred(self, localctx:WhereContext, predIndex:int):
if predIndex == 20:
return self.precpred(self._ctx, 1)
[docs]
def selectCaseBody_sempred(self, localctx:SelectCaseBodyContext, predIndex:int):
if predIndex == 21:
return self.precpred(self._ctx, 1)
[docs]
def structureComponent_sempred(self, localctx:StructureComponentContext, predIndex:int):
if predIndex == 22:
return self.precpred(self._ctx, 1)
[docs]
def pointerField_sempred(self, localctx:PointerFieldContext, predIndex:int):
if predIndex == 23:
return self.precpred(self._ctx, 1)
[docs]
def allocateObject_sempred(self, localctx:AllocateObjectContext, predIndex:int):
if predIndex == 24:
return self.precpred(self._ctx, 1)
[docs]
def ioControlSpecList_sempred(self, localctx:IoControlSpecListContext, predIndex:int):
if predIndex == 25:
return self.precpred(self._ctx, 1)
[docs]
def rdIoCtlSpecList_sempred(self, localctx:RdIoCtlSpecListContext, predIndex:int):
if predIndex == 26:
return self.precpred(self._ctx, 1)
[docs]
def outputItemList1_sempred(self, localctx:OutputItemList1Context, predIndex:int):
if predIndex == 27:
return self.precpred(self._ctx, 2)
if predIndex == 28:
return self.precpred(self._ctx, 1)
[docs]
def uFExpr_sempred(self, localctx:UFExprContext, predIndex:int):
if predIndex == 29:
return self.precpred(self._ctx, 1)
[docs]
def uFTerm_sempred(self, localctx:UFTermContext, predIndex:int):
if predIndex == 30:
return self.precpred(self._ctx, 2)
if predIndex == 31:
return self.precpred(self._ctx, 1)
[docs]
def expression_sempred(self, localctx:ExpressionContext, predIndex:int):
if predIndex == 32:
return self.precpred(self._ctx, 1)
[docs]
def acValueList1_sempred(self, localctx:AcValueList1Context, predIndex:int):
if predIndex == 33:
return self.precpred(self._ctx, 2)
if predIndex == 34:
return self.precpred(self._ctx, 1)
[docs]
def functionArgList_sempred(self, localctx:FunctionArgListContext, predIndex:int):
if predIndex == 35:
return self.precpred(self._ctx, 2)