javacc-7.0.3.grammars.Cobol.jj Maven / Gradle / Ivy
/**
* This is an experimental COBOL-85 grammar for JavaCC.
* References used for this grammar :
* - Ralf Lämmel & Chris Verhoef : VS COBOL II grammar Version 1.0.3
*
- Fujitsu Cobol compiler reference
*
- Compaq-HP Non-stop Cobol reference
*
*
This grammar is released under the GNU Library Public License (LGPL).
*
Bernard Pinon, august 2002
* Thierry Blind, september 2009
* @see http://www.gnu.org/licenses/lgpl.html
* @see http://www.cwi.nl/
* @see http://www.wins.uva.nl/
* @author Thierry Blind (initial work from Bernard Pinon)
*
* History:
* 9-aug-2002 [BP] make changes to comply with JTB :
* - Changed Integer() to IntegerConstant() to avoid conflicts with java.lang.Integer
*
- Removed Java code to make the grammar bare bone
*
- Fixed Identification Division entries
*
* 8-aug-2002 [BP] fixed several bugs :
* - INSTALLATION section
*
- wrong spelling in keywords
*
- DOT missing in FD/SD entries
*
- wrong regular expressions for levels
*
- possibility to have repeated string literals, e.g. "AA" "BB" -> "AABB"
*
- optimized data division by placing the most common clauses first
*
- DOT missing in exit statement
*
- confusion between Identifier and QualifiedDataName (to be checked)
*
- fixed NumericConstant to use Integer instead of INTEGER
*
- Correcting AdvancingPhrase so LINE is optional
*
- Fixed problems with abbreviated conditions
*
- Fixed Add statement
*
* 01-sept-2009 :
* - corrected picture values and enhanced linkage section
*
- corrected relational operators, arithmetic expressions and conditions
*
- corrected perform, evaluate and call clauses
*
- corrected cobol word, litteral, identifier, comment declarations
*
- created Iterables*() variants for some clauses
*
- added function support from cobol 2000
*
- added LOOKAHEAD() instructions, with reorderings, to remove parser ambiguities
*
- ... and many many corrections, new clauses and new tokens relative to cobol 85 and (some from) cobol 2000
*
*
*/
/**
* Cobol is not case sensitive. It is not LL(1) neither...
*/
options {
IGNORE_CASE = true;
//FORCE_LA_CHECK = true;
LOOKAHEAD = 3;
//DEBUG_PARSER = true;
//DEBUG_LOOKAHEAD = true;
STATIC = false;
}
/**
* The parser class.
*/
PARSER_BEGIN(CobolParser)
package convex.step2.parser;
public class CobolParser {
}
PARSER_END(CobolParser)
////////////////////////////////////////////////////////////////////////////////
// Lexical structure
////////////////////////////////////////////////////////////////////////////////
SPECIAL_TOKEN :
{
< EOL: "\n" >
| < SPACECHAR: ( " " | "\t" | "\f" | ";" | "\r" )+ >
}
SPECIAL_TOKEN :
{
< COMMENT: ( "*>" | "|" ) (~["\n","\r"])* >
| < PREPROC_COMMENT: "*|" (~["\n","\r"])* >
| < SPACE_SEPARATOR : ( | )+ >
| < COMMA_SEPARATOR : "," >
}
TOKEN :
{
// TODO : Could be simplified by ?
< DOT : >
}
////////////////////////////////////////////////////////////////////////////////
// RESERVED WORDS. Looks like an excerpt of the dictionary of data processing.
// It is very hard to find significative identifiers in COBOL that are not
// reserved...
////////////////////////////////////////////////////////////////////////////////
TOKEN :
{
/* A */
< ACCEPT: "accept" >
| < ACCESS: "access" >
| < ADD: "add" >
| < ADDRESS: "address" > // extension to support pointers
| < ADVANCING: "advancing" >
| < AFTER: "after" >
| < ALL: "all" >
| < ALPHABET: "alphabet" >
| < ALPHABETIC: "alphabetic" >
| < ALPHABETIC_LOWER: "alphabetic-lower" >
| < ALPHABETIC_UPPER: "alphabetic-upper" >
| < ALPHANUMERIC: "alphanumeric" >
| < ALPHANUMERIC_EDITED: "alphanumeric-edited" >
| < ALSO: "also" >
| < ALTER: "alter" >
| < ALTERNATE: "alternate" >
| < AND: "and" >
| < ANY: "any" >
| < APPROXIMATE: "approximate" > // tandem extension
| < ARE: "are" >
| < AREA: "area" >
| < AREAS: "areas" >
| < ASCENDING: "ascending" >
| < ASSIGN: "assign" >
| < AT: "at" >
| < AUTHOR: "author" >
/* B */
| < BEFORE: "before" >
| < BEGINNING: "beginning" > // extension
| < BINARY: "binary" >
| < BLANK: "blank" >
| < BLOCK: "block" >
| < BOTTOM: "bottom" >
| < BY: "by" >
/* C */
| < CALL: "call" >
| < CALL_CONVENTION: "call-convention" >
| < CANCEL: "cancel" >
| < CD: "cd" >
| < CF: "cf" >
| < CH: "ch" >
| < CHARACTER: "character" >
| < CHARACTERS: "characters" >
| < CLASS: "class" >
| < CLOCK_UNITS: "clock-units" >
| < CLOSE: "close" >
//| < COBOL: "cobol" >
| < CODE: "code" >
| < CODE_SET: "code-set" >
| < COLLATING: "collating" >
| < COLUMN: "column" >
| < COMMA: "comma" >
| < COMMON: "common" >
| < COMMUNICATION: "communication" >
| < COMP: "comp" >
| < COMP_1: "comp-1" > // extension in many dialects
| < COMP_2: "comp-2" > // extension in many dialects
| < COMP_3: "comp-3" > // extension in many dialects
| < COMP_4: "comp-4" > // extension in many dialects
| < COMPUTATIONAL: "computational" >
| < COMPUTATIONAL_1: "computational-1" > // extension
| < COMPUTATIONAL_2: "computational-2" > // extension
| < COMPUTATIONAL_3: "computational-3" > // extension
| < COMPUTATIONAL_4: "computational-4" > // extension
| < COMPUTE: "compute" >
| < CONFIGURATION: "configuration" >
| < CONTAINS: "contains" >
| < CONTENT: "content" >
| < CONTINUE: "continue" >
| < CONTROL: "control" >
| < CONTROLS: "controls" >
| < CONVERTING: "converting" >
| < COPY: "copy" >
| < CORR: "corr" >
| < CORRESPONDING: "corresponding" >
| < COUNT: "count" >
| < CURRENCY: "currency" >
/* D */
| < DATA: "data" >
| < DATE: "date" >
| < DATE_COMPILED: "date-compiled" >
| < DATE_WRITTEN: "date-written" >
| < DAY: "day" >
| < DAY_OF_WEEK: "day-of-week" >
| < DBCS: "dbcs" > // extension to support double bytes characters
| < DE: "de" >
| < DEBUG_CONTENTS: "debug-contents" >
| < DEBUG_ITEM: "debug-item" >
| < DEBUG_LINE: "debug-line" >
| < DEBUG_NAME: "debug-name" >
| < DEBUG_SUB_1: "debug-sub-1" >
| < DEBUG_SUB_2: "debug-sub-2" >
| < DEBUG_SUB_3: "debug-sub-3" >
| < DEBUGGING: "debugging" >
| < DECIMAL_POINT: "decimal-point" >
| < DECLARATIVES: "declaratives" >
| < DELETE: "delete" >
| < DELIMITED: "delimited" >
| < DELIMITER: "delimiter" >
| < DEPENDING: "depending" >
| < DESCENDING: "descending" >
| < DESCRIPTOR: "descriptor" >
| < DESTINATION: "destination" >
| < DETAIL: "detail" >
| < DISABLE: "disable" >
| < DISPLAY: "display" >
| < DISPLAY_1: "display-1" > // extension
| < DIVIDE: "divide" >
| < DIVISION: "division" >
| < DOWN: "down" >
| < DUPLICATES: "duplicates" >
| < DYNAMIC: "dynamic" >
/* E */
| < EGCS: "egcs" > // extension
| < EGI: "egi" >
| < ELSE: "else" >
| < EMI: "emi" >
| < ENABLE: "enable" >
| < END: "end" >
| < END_ADD: "end-add" >
| < END_CALL: "end-call" >
| < END_COMPUTE: "end-compute" >
| < END_DELETE: "end-delete" >
| < END_DIVIDE: "end-divide" >
| < END_EVALUATE: "end-evaluate" >
| < END_IF: "end-if" >
| < END_MULTIPLY: "end-multiply" >
| < END_OF_PAGE: "end-of-page" >
| < END_PERFORM: "end-perform" >
| < END_READ: "end-read" >
| < END_RECEIVE: "end-receive" >
| < END_RETURN: "end-return" >
| < END_REWRITE: "end-rewrite" >
| < END_SEARCH: "end-search" >
| < END_START: "end-start" >
| < END_STRING: "end-string" >
| < END_SUBTRACT: "end-subtract" >
| < END_UNSTRING: "end-unstring" >
| < END_WRITE: "end-write" >
| < ENDING: "endinf" >
| < ENTER: "enter" > // not present in all COBOLs, use CALL instead
| < ENTRY: "entry" >
| < ENVIRONMENT: "environment" >
| < EOP: "eop" >
| < EQUAL: "equal" >
| < ERROR: "error" >
| < ESI: "esi" >
| < EVALUATE: "evaluate" >
| < EVERY: "every" >
| < EXCEPTION: "exception" >
/* | < EXCLUSIVE: "exclusive" > tandem extension */
| < EXIT: "exit" >
| < EXTEND: "extend" >
| < EXTERNAL: "external" >
/* F */
| < FALSE: "false" >
| < FD: "fd" >
| < FILE: "file" >
| < FILE_CONTROL: "file-control" >
| < FILLER: "filler" >
| < FINAL: "final" >
| < FIRST: "first" >
| < FOOTING: "footing" >
| < FOR: "for" >
| < FROM: "from" >
| < FUNCTION: "function" >
/* G */
| < GENERATE: "generate" >
| < GOBACK: "goback" > // extension
| < GENERIC: "generic" > // tandem extension
| < GIVING: "giving" >
| < GLOBAL: "global" >
| < GO: "go" >
| < GREATER: "greater" >
| < GROUP: "group" >
/* H */
| < HEADING: "heading" >
| < HIGH_VALUE: "high-value" >
| < HIGH_VALUES: "high-values" >
/* I */
| < I_O: "i-o" >
| < I_O_CONTROL: "i-o-control" >
| < ID: "id" > // extension, synonym for IDENTIFICATION
| < IDENTIFICATION: "identification" >
| < IDENTIFIED: "identified" >
| < IF: "if" >
| < IMPLICIT: "implicit" >
| < IN: "in" >
| < INDEX: "index" >
| < INDEXED: "indexed" >
| < INDICATE: "indicate" >
| < INITIAL: "initial" >
| < INITIALIZE: "initialize" >
| < INITIATE: "initiate" >
| < INPUT: "input" >
| < INPUT_OUTPUT: "input-output" >
| < INSPECT: "inspect" >
| < INSTALLATION: "installation" >
| < INTO: "into" >
| < INVALID: "invalid" >
| < IS: "is" >
/* J */
| < JUST: "just" >
| < JUSTIFIED: "justified" >
| < JUSTIFY: "justify" >
/* K */
| < KANJI: "kanji" > // extension to support Kanji characters (japanese)
| < KEY: "key" >
/* L */
| < LABEL: "label" >
| < LAST: "last" >
| < LEADING: "leading" >
| < LEFT: "left" >
| < LENGTH: "length" >
| < LESS: "less" >
| < LIMIT: "limit" >
| < LIMITS: "limits" >
| < LINAGE: "linage" >
| < LINAGE_COUNTER: "linage_counter" >
| < LINE: "line" >
| < LINES: "lines" >
| < LINE_COUNTER: "line-counter" >
| < LINKAGE: "linkage" >
| < LOCK: "lock" >
| < LOCKFILE: "lockfile" > // tandem extension
| < LOW_VALUE: "low-value" >
| < LOW_VALUES: "low-values" >
/* M */
| < MEMORY: "memory" >
| < MERGE: "merge" >
| < MESSAGE: "message" >
| < MODE: "mode" >
| < MODULES: "modules" >
| < MORE_LABELS: "more-labels" > // IBM extension
| < MOVE: "move" >
| < MULTIPLE: "multiple" >
| < MULTIPLY: "multiply" >
/* N */
| < NATIVE: "native" >
| < NEGATIVE: "negative" >
| < NEXT: "next" >
| < NO: "no" >
| < NOT: "not" >
| < NULL: "null" > // tandem & IBM extension
| < NULLS: "nulls" > // tandem & IBM extension
| < NUMBER: "number" >
| < NUMERIC: "numeric" >
| < NUMERIC_EDITED: "numeric-edited" >
/* O */
| < OBJECT_COMPUTER: "object-computer" >
| < OCCURS: "occurs" >
| < OF: "of" >
| < OFF: "off" >
| < OMITTED: "omitted" >
| < ON: "on" >
| < OPEN: "open" >
| < OPTIONAL: "optional" >
| < OR: "or" >
| < ORDER: "order" >
| < ORGANIZATION: "organization" >
| < OTHER: "other" >
| < OUTPUT: "output" >
| < OVERFLOW: "overflow" >
/* P */
| < PACKED_DECIMAL: "packed-decimal" >
| < PADDING: "padding" >
| < PAGE: "page" >
| < PAGE_COUNTER: "page-counter" >
| < PASSWORD: "password" >
| < PERFORM: "perform" >
| < PF: "pf" >
| < PH: "ph" >
| < PIC: "pic" >
| < PICTURE: "picture" >
| < PLUS: "plus" >
| < POINTER: "pointer" >
| < POSITION: "position" >
| < POSITIVE: "positive" >
| < PRINTING: "printing" >
| < PROCEDURE: "procedure" >
| < PROCEDURES: "procedures" >
| < PROCEDURE_POINTER: "procedure-pointer" >
| < PROCEED: "proceed" >
| < PROGRAM: "program" >
| < PROGRAM_ID: "program-id" >
| < PROGRAM_STATUS: "program-status" > // tandem extension
| < PROMPT: "prompt" > // tandem extension
| < PROTECTED: "protected" > // tandem extension
| < PURGE: "purge" >
/* Q */
| < QUEUE: "queue" >
| < QUOTE: "quote" >
| < QUOTES: "quotes" >
/* R */
| < RANDOM: "random" >
| < RD: "rd" >
| < READ: "read" >
| < RECEIVE: "receive" >
| < RECEIVE_CONTROL: "receive-control" > // tandem extension
| < RECORD: "record" >
| < RECORDING: "recording" > // probably IBM extension
| < RECORDS: "records" >
| < REDEFINES: "redefines" >
| < REEL: "reel" >
| < REFERENCE: "reference" >
| < REFERENCES: "references" >
| < RELATIVE: "relative" >
| < RELEASE: "release" >
| < REMAINDER: "remainder" >
| < REMOVAL: "removal" >
| < RENAMES: "renames" >
| < REPLACE: "replace" >
| < REPLACING: "replacing" >
| < REPLY: "reply" > // tandem extension
| < REPORT: "report" >
| < REPORTING: "reporting" >
| < REPORTS: "reports" >
| < RERUN: "rerun" >
| < RESERVE: "reserve" >
| < RESET: "reset" >
| < RETURN: "return" > // IBM extension - does not do what expected ;-)
| < RETURN_CODE: "return-code" > // special register IBM
| < RETURNED: "returned" >
| < RETURNING: "returning" >
| < REVERSED: "reversed" >
| < REWIND: "rewind" >
| < REWRITE: "rewrite" >
| < RF: "rf" >
| < RH: "rh" >
| < RIGHT: "right" >
| < ROUNDED: "rounded" >
| < RUN: "run" >
/* S */
| < SAME: "same" >
| < SD: "sd" >
| < SEARCH: "search" >
| < SECTION: "section" >
| < SECURITY: "security" >
| < SEGMENT: "segment" >
| < SEGMENT_LIMIT: "segment-limit" >
| < SELECT: "select" >
| < SEND: "send" >
| < SENTENCE: "sentence" >
| < SEPARATE: "separate" >
| < SEQUENCE: "sequence" >
| < SEQUENTIAL: "sequential" >
| < SET: "set" >
| < SHARED: "shared" > // tandem extension, should be in C2000
| < SHIFT_IN: "shift-in" > // IBM special register
| < SHIFT_OUT: "shift-out" > // IBM special register
| < SIGN: "sign" >
| < SIZE: "size" >
| < SORT: "sort" >
| < SORT_CONTROL: "sort-control" > // IBM special register
| < SORT_CORE_SIZE: "sort-core-size" > // IBM special register
| < SORT_FILE_SIZE: "sort-file-size" > // IBM special register
| < SORT_MERGE: "sort-merge" >
| < SORT_MESSAGE: "sort-message" > // IBM special register
| < SORT_MODE_SIZE: "sort-mode-size" > // IBM special register
| < SORT_RETURN: "sort-return" > // IBM special register
| < SOURCE: "source" >
| < SOURCE_COMPUTER: "source-computer" >
| < SPACE: "space" >
| < SPACES: "spaces" >
| < SPECIAL_NAMES: "special-names" >
| < STANDARD: "standard" >
| < STANDARD_1: "standard-1" >
| < STANDARD_2: "standard-2" >
| < START: "start" >
| < STATUS: "status" >
| < STDCALL: "stdcall" >
| < STOP: "stop" >
| < STRING: "string" >
| < SUB_QUEUE_1: "sub-queue-1" >
| < SUB_QUEUE_2: "sub-queue-2" >
| < SUB_QUEUE_3: "sub-queue-3" >
| < SUBTRACT: "subtract" >
| < SUM: "sum" >
| < SUPPRESS: "suppress" >
| < SYMBOLIC: "symbolic" >
| < SYNC: "sync" >
| < SYNCHRONIZED: "synchronized" >
/* T */
| < TABLE: "table" >
| < TALLY: "tally" > // IBM special register
| < TALLYING: "tallying" >
| < TAPE: "tape" >
| < TERMINAL: "terminal" >
| < TERMINATE: "terminate" >
| < TEST: "test" >
| < TEXT: "text" >
| < THAN: "than" >
| < THEN: "then" >
| < THROUGH: "through" >
| < THRU: "thru" >
| < TIME: "time" >
| < TIMES: "times" >
| < TO: "to" >
| < TOP: "top" >
| < TRAILING: "trailing" >
| < TRUE: "true" >
| < TYPE: "type" >
/* U */
| < UNIT: "unit" >
| < UNLOCK: "unlock" > // tandem extension
| < UNLOCKFILE: "unlockfile" > // tandem again
| < UNLOCKRECORD: "unlockrecord" > // guess what
| < UNSTRING: "unstring" >
| < UNTIL: "until" >
| < UP: "up" >
| < UPON: "upon" >
| < USAGE: "usage" >
| < USE: "use" >
| < USING: "using" >
/* V */
| < VALUE: "value" >
| < VALUES: "values" >
| < VARYING: "varying" >
/* W */
| < WHEN: "when" >
| < WHEN_COMPILED: "when-compiled" > // IBM special register
| < WITH: "with" >
| < WORDS: "words" >
| < WORKING_STORAGE: "working-storage" >
| < WRITE: "write" >
/* Z */
| < ZERO: "zero" >
| < ZEROS: "zeros" >
| < ZEROES: "zeroes" >
/* Newly added */
| < ALPHANUMERIC_HASHTABLE: "alphanumeric-hashtable" >
| < BINARY_BYTE: "binary-byte" >
| < BINARY_DOUBLE: "binary-double" >
| < BINARY_LONG: "binary-long" >
| < BINARY_M: "binary-m" >
| < BINARY_REV: "binary-rev" >
| < BINARY_SHORT: "binary-short" >
| < BIT: "bit" >
| < COMPONENT: "component" >
| < COMPUTATIONAL_2_A: "computational-2-a" >
| < COMPUTATIONAL_1_A: "computational-1-a" >
| < COMPUTATIONAL_1_E: "computational-1-e" >
| < COMPUTATIONAL_1_M: "computational-1-m" >
| < COMPUTATIONAL_1_MVS: "computational-1-mvs" >
| < COMPUTATIONAL_1_REV: "computational-1-rev" >
| < COMPUTATIONAL_2_E: "computational-2-e" >
| < COMPUTATIONAL_2_M: "computational-2-m" >
| < COMPUTATIONAL_2_MVS: "computational-2-mvs" >
| < COMPUTATIONAL_2_REV: "computational-2-rev" >
| < COMPUTATIONAL_3_A: "computational-3-a" >
| < COMPUTATIONAL_3_M: "computational-3-m" >
| < COMPUTATIONAL_4_M: "computational-4-m" >
| < COMPUTATIONAL_5: "computational-5" >
| < COMPUTATIONAL_5_M: "computational-5-m" >
| < COMPUTATIONAL_6: "computational-6" >
| < COMPUTATIONAL_A: "computational-a" >
| < COMPUTATIONAL_B: "computational-b" >
| < COMPUTATIONAL_D: "computational-d" >
| < COMPUTATIONAL_M: "computational-m" >
| < COMPUTATIONAL_N: "computational-n" >
| < COMPUTATIONAL_P: "computational-p" >
| < COMPUTATIONAL_S: "computational-s" >
| < COMPUTATIONAL_X: "computational-x" >
| < COMPUTATIONAL_X_REV: "computational-x-rev" >
| < COMP_1_A: "comp-1-a" >
| < COMP_1_E: "comp-1-e" >
| < COMP_1_M: "comp-1-m" >
| < COMP_1_MVS: "comp-1-mvs" >
| < COMP_1_REV: "comp-1-rev" >
| < COMP_2_A: "comp-2-a" >
| < COMP_2_E: "comp-2-e" >
| < COMP_2_M: "comp-2-m" >
| < COMP_2_MVS: "comp-2-mvs" >
| < COMP_2_REV: "comp-2-rev" >
| < COMP_3_A: "comp-3-a" >
| < COMP_3_M: "comp-3-m" >
| < COMP_4_M: "comp-4-m" >
| < COMP_5: "comp-5" >
| < COMP_5_M: "comp-5-m" >
| < COMP_6: "comp-6" >
| < COMP_A: "comp-a" >
| < COMP_B: "comp-b" >
| < COMP_D: "comp-d" >
| < COMP_M: "comp-m" >
| < COMP_N: "comp-n" >
| < COMP_P: "comp-p" >
| < COMP_S: "comp-s" >
| < COMP_X: "comp-x" >
| < COMP_X_REV: "comp-x-rev" >
| < DEFAULT_FONT: "default-font" >
| < DISPLAY_WS: "display-ws" >
| < DOUBLE: "double" >
| < EXTERNAL_FORM: "external-form" >
| < FIXED_FONT: "fixed-font" >
| < FLOAT: "float" >
| < FLOAT_LONG: "float-long" >
| < FLOAT_SHORT: "float-short" >
| < FONT: "font" >
| < HANDLE: "handle" >
| < JBOOLEAN: "jboolean" >
| < JBYTE: "jbyte" >
| < JCHAR: "jchar" >
| < JDOUBLE: "jdouble" >
| < JFLOAT: "jfloat" >
| < JINT: "jint" >
| < JLONG: "jlong" >
| < JPACKED_DECIMAL: "jpacked-decimal" >
| < JSHORT: "jshort" >
| < JSTRING: "jstring" >
| < LARGE_FONT: "large-font" >
| < MEDIUM_FONT: "medium-font" >
| < NATIONAL: "national" >
| < NUMERIC_HASHTABLE: "numeric-hashtable" >
| < OBJECT: "object" >
| < OBJECT_HASHTABLE: "object-hashtable" >
| < PACKED_DECIMAL_A: "packed-decimal-a" >
| < PACKED_DECIMAL_E: "packed-decimal-e" >
| < PACKED_DECIMAL_H: "packed-decimal-h" >
| < PACKED_DECIMAL_I: "packed-decimal-i" >
| < PACKED_DECIMAL_M: "packed-decimal-m" >
| < SIGNED_INT: "signed-int" >
| < SIGNED_LONG: "signed-long" >
| < SIGNED_SHORT: "signed-short" >
| < SMALL_FONT: "small-font" >
| < SQLIND: "sqlind" >
| < THREAD: "thread" >
| < TRADITIONAL_FONT: "traditional-font" >
| < UNSIGNED_INT: "unsigned-int" >
| < UNSIGNED_LONG: "unsigned-long" >
| < UNSIGNED_SHORT: "unsigned-short" >
| < WINDOW: "window" >
}
TOKEN :
{
< LEVEL_66: "66" >
| < LEVEL_77: "77" >
| < LEVEL_88: "88" >
| < LEVEL_NUMBER: ( (("0")? ["1"-"9"]) | (["1"-"4"]["0"-"9"]) | "78" ) >
| < INTEGER: (["0"-"9"])+ >
| < MINUSCHAR: "-" > // a.k.a. dash
| < LPARENCHAR: "(" >
| < RPARENCHAR: ")" >
| < COLONCHAR: ":" >
| < DOTCHAR: "." >
| < COMMACHAR: "," >
| < DOUBLEDQUOTECHAR: "\"\"" >
| < QUOTECHAR: "\"" >
| < DOUBLEDAPOSTROPHE: "''" >
| < APOSTROPHE: "'" >
| < PLUSCHAR: "+" >
| < ASTERISKCHAR: "*" >
| < POWEROF: "**" >
| < SLASHCHAR: "/" >
| < DOLLARCHAR: "$" >
| < LESSTHANOREQUAL: "<=" >
| < LESSTHANCHAR: "<" >
| < MORETHANOREQUAL: ">=" >
| < MORETHANCHAR: ">" >
| < EQUALCHAR: "=" >
| < NOTEQUAL: "<>" >
| < HEXNUMBER: ["h","x"] ( ( ( ["0"-"9","a"-"f"] )+ )
| ( ( ["0"-"9","a"-"f"] )+ )
)
>
| < QUOTEDSTRING: ( (~["\""] | )*
| (~["'"] | )*
)
>
// NB : COBOL_WORD can be defined as an INTEGER (or a LEVEL_66* or a LEVEL_NUMBER) too !
| < COBOL_WORD: (["a"-"z","0"-"9"])+ ( ( | "_" )+ (["a"-"z","0"-"9"])+ )* >
| < OTHER_CHARS: ~[] >
}
// Contains at least one alphabetic, max. 30 char
void CobolWord() :
{}
{
}
void QuotedText() :
{}
{
( IterableQuotedText() )+
}
void IterableQuotedText() :
{}
{
| |
}
void IntegerConstant() :
{}
{
| | | |
}
void NumericConstant() :
{}
{
[ | ] ( ( | ) IntegerConstant() | IntegerConstant() [ ( | ) IntegerConstant() ] )
}
void LevelNumber() :
{}
{
}
void FigurativeConstant() :
{}
{
| |
| |
| |
| |
| |
| |
}
void NonNumericConstant() :
{}
{
( QuotedText()
|
)
}
void IterableNonNumericConstant() :
{}
{
( IterableQuotedText()
|
)
}
void Literal() :
{}
{
[ ] ( NonNumericConstant()
| NumericConstant()
/* | */
| FigurativeConstant()
)
}
void IterableLiteral() :
{}
{
[ ] ( IterableNonNumericConstant()
| NumericConstant()
/* | */
| FigurativeConstant()
)
}
////////////////////////////////////////////////////////////////////////////////
// LOGICAL EXPRESSIONS (e.g. in IF statements)
// one of the nice feature of COBOL is to allow for abbeviated conditions
// such as : if X less than 100 and more than 10 then ...
////////////////////////////////////////////////////////////////////////////////
void IterableCondition() :
{}
{
// TODO : This step was created because of the ambiguite of the rule ClassCondition() inside of RelationCondition() :
// CobolWord() CobolWord() === ArithmeticExpression() ClassCondition()
LOOKAHEAD(ArithmeticExpression())
ArithmeticExpression()
| Condition()
}
void Condition() :
{}
{
CombinableCondition() ( ( | ) ( LOOKAHEAD(CombinableCondition()) CombinableCondition() | AbbreviationRest() ) )*
}
void CombinableCondition() :
{}
{
[ ] SimpleCondition()
}
void SimpleCondition() :
{}
{
LOOKAHEAD(RelationCondition())
RelationCondition()
| LOOKAHEAD(ArithmeticExpression())
ArithmeticExpression()
| Condition()
}
void ClassCondition() :
{}
{
[ ] [ ] ( | | | | ClassName() | | )
}
void RelationCondition() :
{}
{
ArithmeticExpression() ( LOOKAHEAD(AbbreviationRest())
AbbreviationRest()
| LOOKAHEAD(SignCondition())
SignCondition()
| ClassCondition()
)
}
void SignCondition() :
{}
{
[ ] [ ] ( | | | | )
}
void RelationalOperator() :
{}
{
[ ] [ ] ( [ ] [ [ ] ]
|
| [ ] [ [ ] ]
|
| [ ]
|
|
|
|
)
}
void AbbreviationLeaf() :
{}
{
LOOKAHEAD(ArithmeticExpression())
ArithmeticExpression()
// TODO : Is there another abbreviation rule ?
| AbbreviationLeaf() ( AbbreviationLeaf() )+
}
void AbbreviationRest() :
{}
{
RelationalOperator() AbbreviationLeaf()
}
////////////////////////////////////////////////////////////////////////////////
// VARIOUS TYPES OF IDENTIFIERS
////////////////////////////////////////////////////////////////////////////////
void ProcedureName() :
{}
{
( ParagraphName() [ ( | ) SectionName() ]
| SectionName() // Useless here ...
)
}
void Subscript() :
{}
{
( ArithmeticExpression() )+
}
void FunctionClause() :
{}
{
FunctionName() [ LOOKAHEAD(Subscript()) Subscript() ] [ LeftmostCharacterPosition() [ Length() ] ]
}
void Identifier() :
{}
{
( QualifiedDataName() ( LOOKAHEAD(Subscript()) Subscript() )* [ LeftmostCharacterPosition() [ Length() ] ]
| [ ( | ) FileName() ]
|
)
}
void QualifiedDataName() :
{}
{
( DataName() ( ( | ) DataName() )*
[ ( | ) FileName() ] // Useless part here ...
| SpecialRegister() // Useless here ...
)
}
void Length() :
{}
{
ArithmeticExpression()
}
void LeftmostCharacterPosition() :
{}
{
ArithmeticExpression()
}
void Mode() :
{}
{
CobolWord()
}
void AlphabetName() :
{}
{
CobolWord()
}
void ClassName() :
{}
{
CobolWord()
}
void ConditionName() :
{}
{
CobolWord()
}
void DataName() :
{}
{
CobolWord()
}
void FileName() :
{}
{
CobolWord()
}
void IndexName() :
{}
{
CobolWord()
}
void MnemonicName() :
{}
{
CobolWord()
}
void RecordName() :
{}
{
Identifier()
}
void RoutineName() :
{}
{
CobolWord()
}
void SymbolicCharacter() :
{}
{
CobolWord()
}
void LibraryName() :
{}
{
CobolWord()
}
void ProgramName() :
{}
{
CobolWord()
}
void SectionName() :
{}
{
// We force IntegerConstant() recognization here ...
IntegerConstant() | CobolWord()
}
void ParagraphName() :
{}
{
// We force IntegerConstant() recognization here ...
IntegerConstant() | CobolWord()
}
void SystemName() :
{}
{
CobolWord()
}
void ComputerName() :
{}
{
SystemName()
}
void LanguageName() :
{}
{
SystemName()
}
void EnvironmentName() :
{}
{
SystemName()
}
void AssignmentName() :
{}
{
SystemName()
}
void BasisName() :
{}
{
ProgramName()
}
void FunctionName() :
{}
{
( CobolWord()
| // To avoid conflicts with token having same name ...
|
|
|
)
}
void SpecialRegister() :
{}
{
( DataName()
|
| Identifier()
|
|
|
|
|
|
|
|
|
|
|
)
}
void CdName() :
{}
{
CobolWord()
}
void ConventionName() :
{}
{
CobolWord()
}
void HandleComponent() :
{}
{
CobolWord()
}
void ImplicitTitle() :
{}
{
QuotedText()
}
void LevelName66() :
{}
{
DataName()
}
void LevelName77() :
{}
{
DataName()
}
void LevelName88() :
{}
{
ConditionName()
}
void LevelName() :
{}
{
[ DataName() | | | ]
}
////////////////////////////////////////////////////////////////////////////////
// ARITHMETIC
////////////////////////////////////////////////////////////////////////////////
void ArithmeticExpression() :
{}
{
TimesDiv() ( ( | ) TimesDiv() )*
}
void TimesDiv() :
{}
{
Power() ( ( | ) Power() )*
}
void Power() :
{}
{
[ ( | ) ] Basis() ( Basis() )*
}
void Basis() :
{}
{
// IMPORTANT : From more complex to most specific :
// TODO : Dirty hack : is a valid value ?
( FunctionClause() | Identifier() | Literal() | | ArithmeticExpression() )
}
void CommentLine() :
{}
{
( ( NonDotChars() | Literal() )+ [ ] )+
}
////////////////////////////////////////////////////////////////////////////////
// COMPILATION UNIT.
////////////////////////////////////////////////////////////////////////////////
void CompilationUnit() :
{}
{
ProgramUnit()
( NestedProgramUnit() EndProgramStatement() )*
[ EndProgramStatement() ( CompilationUnit() )* ]
}
void ProgramUnit() :
{}
{
IdentificationDivision()
[ EnvironmentDivision() ]
[ DataDivision() ]
[ ProcedureDivision() ]
}
void NestedProgramUnit() :
{}
{
NestedIdentificationDivision()
[ EnvironmentDivision() ]
[ DataDivision() ]
[ ProcedureDivision() ]
}
void EndProgramStatement() :
{}
{
ProgramName()
}
void CopyBookUnit() :
{}
{
LinkageSectionEntry()
}
////////////////////////////////////////////////////////////////////////////////
// IDENTIFICATION DIVISION.
////////////////////////////////////////////////////////////////////////////////
void IdentificationDivision() :
{}
{
( | )
ProgramIdParagraph()
( IdentificationDivisionParagraph() )*
}
void NestedIdentificationDivision() :
{}
{
( | )
NestedProgramIdParagraph()
( IdentificationDivisionParagraph() )*
}
void IdentificationDivisionParagraph() :
{}
{
AuthorParagraph()
| InstallationParagraph()
| DateWrittenParagraph()
| DateCompiledParagraph()
| SecurityParagraph()
}
void ProgramIdParagraph() :
{}
{
ProgramName() [ [ ] [ ] ]
}
void NestedProgramIdParagraph() :
{}
{
ProgramName()
[ [ ] InitialOrCommon() [ ] ]
}
void InitialOrCommon() :
{}
{
( [ ]
| [ ]
)
}
void AuthorParagraph() :
{ /* System.out.println("Deprecated keyword : author - use a comment"); */ }
{
[ CommentLine() ]
}
void InstallationParagraph() :
{ /* System.out.println("Deprecated keyword : installation - use a comment"); */ }
{
[ CommentLine() ]
}
void DateWrittenParagraph() :
{ /* System.out.println("Deprecated keyword : date-written - use a comment"); */ }
{
[ CommentLine() ]
}
void DateCompiledParagraph() :
{ /* System.out.println("Deprecated keyword : date-compiled - use a comment"); */ }
{
[ CommentLine() ]
}
void SecurityParagraph() :
{ /* System.out.println("Deprecated keyword : security - use a comment"); */ }
{
[ CommentLine() ]
}
////////////////////////////////////////////////////////////////////////////////
// ENVIRONMENT DIVISION.
////////////////////////////////////////////////////////////////////////////////
void EnvironmentDivision() :
{}
{
( EnvironmentSection() )*
}
void EnvironmentSection() :
{}
{
ConfigurationSection()
| InputOutputSection()
}
//------------------------------------------------------------------------------
// CONFIGURATION SECTION
//------------------------------------------------------------------------------
void ConfigurationSection() :
{}
{
( ConfigurationSectionParagraph() )*
}
void ConfigurationSectionParagraph() :
{}
{
SourceComputerParagraph()
| ObjectComputerParagraph()
| SpecialNamesParagraph()
}
void SourceComputerParagraph() :
{}
{
ComputerName() [ [ ] ]
}
void ObjectComputerParagraph() :
{}
{
ComputerName() ( ObjectComputerClause() )*
}
void ObjectComputerClause() :
{}
{
MemorySizeClause()
| CollatingSequenceClause()
| SegmentLimitClause()
| CharacterSetClause()
}
void MemorySizeClause() :
{ /* System.out.println("Deprecated keyword : memory - use a comment"); */ }
{
[ ] IntegerConstant() [ | | ]
}
void CollatingSequenceClause() :
{ /* System.out.println("Deprecated keyword : collating sequence - use a comment"); */ }
{
[ ] [ ] [ ] AlphabetName()
}
void SegmentLimitClause() :
{ /* System.out.println("Deprecated keyword : segment unit - use a comment"); */ }
{
( | ) [ ] IntegerConstant()
}
// Tandem ???
void CharacterSetClause() :
{}
{
[ CommentLine() ]
}
void SpecialNamesParagraph() :
{}
{
[ ( SpecialNameClause() )+ ]
}
void SpecialNameClause() :
{}
{
AlphabetClause()
| ClassClause()
| CurrencySignClause()
| DecimalPointClause()
| SymbolicCharactersClause()
| CallConventionClause()
| EnvironmentNameIsMnemonicNameClause()
}
void IterableAlphabetPhrase() :
{}
{
( | ) IterableLiteral()
| ( IterableLiteral() )+
}
void AlphabetClause() :
{}
{
AlphabetName() [ ]
(
|
|
| CobolWord()
| ( IterableLiteral() [ IterableAlphabetPhrase() ] )+
)
}
void ClassClause() :
{}
{
// TODO (SUPPRESS) : Dirty hack : IterableLiteral() --> Identifier() | IterableLiteral()
ClassName() [ ] ( ( Identifier() | IterableLiteral() ) [ ( | ) ( Identifier() | IterableLiteral() ) ] )+
}
void CurrencySignClause() :
{}
{
[ ] [ ] Literal()
}
void DecimalPointClause() :
{}
{
[ ]
}
void SymbolicCharactersClause() :
{}
{
[ ] ( ( SymbolicCharacter() )+ [ ( | ) ] ( NumericConstant() | )+ )+ [ AlphabetName() ]
}
void CallConventionClause() :
{}
{
IntegerConstant() [