pd.if.org Git - pccts/blob - antlr/antlr.mpw.r

   1 #include "cmdo.r"
   2
   3 resource 'cmdo' (128, "Antlr") {
   4         {
   5                 /* [1] */
   6                 295,
   7                 "ANTLR -- Purdue Compiler Construction Tool Set (PCCTS) LL(k) parser generator.",
   8                 {
   9                         /* [1] */
  10                         NotDependent { }, MultiFiles {
  11                                 "Grammar File(s)É",
  12                                 "Choose the grammar specification files you wish to have ANTLR process.",
  13                                 {25, 24, 44, 154},
  14                                 "Grammar specification:",
  15                                 "",
  16                                 MultiInputFiles {
  17                                         {       /* array MultiTypesArray: 1 elements */
  18                                                 /* [1] */
  19                                                 text
  20                                         },
  21                                         ".g",
  22                                         "Files ending in .g",
  23                                         "All text files"
  24                                 }
  25                         },
  26                         /* [2] */
  27                         NotDependent { }, Files {
  28                                 DirOnly,
  29                                 OptionalFile {
  30                                         {56, 25, 72, 155},
  31                                         {77, 25, 96, 155},
  32                                         "Output Directory",
  33                                         ":",
  34                                         "-o",
  35                                         "",
  36                                         "Choose the directory where ANTLR will put its output.",
  37                                         dim,
  38                                         "Output DirectoryÉ",
  39                                         "",
  40                                         ""
  41                                 },
  42                                 NoMore {
  43
  44                                 }
  45                         },
  46                         /* [3] */
  47                         NotDependent { }, Redirection {
  48                                 StandardOutput,
  49                                 {126, 27}
  50                         },
  51                         /* [4] */
  52                         NotDependent { }, Redirection {
  53                                 DiagnosticOutput,
  54                                 {126, 178}
  55                         },
  56                         /* [5] */
  57                         NotDependent { }, TextBox {
  58                                 gray,
  59                                 {117, 20, 167, 300},
  60                                 "Redirection"
  61                         },
  62                         /* [6] */
  63                         NotDependent { }, NestedDialog {
  64                                 2,
  65                                 {20, 324, 40, 460},
  66                                 "OptionsÉ",
  67                                 "Various command line options may be set "
  68                                 "with this button."
  69                         },
  70                         /* [7] */
  71                         NotDependent { }, NestedDialog {
  72                                 3,
  73                                 {48, 324, 68, 460},
  74                                 "More OptionsÉ",
  75                                 "Antlr has ALOT of options. There are even more to be found with this button."
  76                         },
  77                         /* [8] */
  78                         NotDependent { }, NestedDialog {
  79                                 4,
  80                                 {76, 324, 96, 460},
  81                                 "Rename OptionsÉ",
  82                                 "Options for renaming output files may be set with this button."
  83                         },
  84                         /* [9] */
  85                         NotDependent { }, VersionDialog {
  86                                 VersionString {
  87                                         "1.33"
  88                                 },
  89                                 "PCCTS was written by Terence Parr, Russell Quong, Will Cohen, and Hank Dietz: 1989-1995. "
  90                                 "MPW port by Scott Haney.",
  91                                 noDialog
  92                         }
  93                 },
  94                 /* [2] */
  95                 295,
  96                 "Use this dialog to specify command line options.",
  97                 {
  98                         /* [1] */
  99                         NotDependent { }, CheckOption {
 100                                 NotSet,
 101                                 {18, 25, 33, 225},
 102                                 "Generate C++ code",
 103                                 "-CC",
 104                                 "Generate C++ output from both ANTLR and DLG."
 105                         },
 106                         /* [2] */
 107                         NotDependent { }, CheckOption {
 108                                 NotSet,
 109                                 {38, 25, 53, 225},
 110                                 "Generate ASTs",
 111                                 "-gt",
 112                                 "Generate code for Abstract-Syntax-Trees (ASTs)."
 113                         },
 114                         /* [3] */
 115                         NotDependent { }, CheckOption {
 116                                 NotSet,
 117                                 {18, 235, 33, 435},
 118                                 "Support parse traces",
 119                                 "-gd",
 120                                 "If this option is checked, ANTLR inserts code in each parsing "
 121                                 "function to provide for user-defined handling of a detailed parse trace. "
 122                                 "The code consists of calls to zzTRACEIN and zzTRACEOUT."
 123                         },
 124                         /* [4] */
 125                         NotDependent { }, CheckOption {
 126                                 NotSet,
 127                                 {58, 25, 73, 225},
 128                                 "Generate line info",
 129                                 "-gl",
 130                                 "If this option is checked, ANTLR will generate line info about grammar"
 131                                 "actions, thereby making debugging easier since "
 132                                 "compile errors will point to the grammar file."
 133                         },
 134                         /* [5] */
 135                         NotDependent { }, CheckOption {
 136                                 NotSet,
 137                                 {38, 235, 53, 435},
 138                                 "Generate cross-references",
 139                                 "-cr",
 140                                 "If this option is checked, ANTLR will generate a cross reference for all "
 141                                 "rules. For each rule it will print a list of all other rules that refrence it."
 142                         },
 143                         /* [6] */
 144                         NotDependent { }, CheckOption {
 145                                 NotSet,
 146                                 {78, 25, 93, 225},
 147                                 "Generate error classes",
 148                                 "-ge",
 149                                 "If this option is checked, ANTLR will generate an error class for"
 150                                 "each non-terminal."
 151                         },
 152                         /* [7] */
 153                         NotDependent { }, CheckOption {
 154                                 NotSet,
 155                                 {58, 235, 73, 435},
 156                                 "Hoist predicate context",
 157                                 "-prc on",
 158                                 "If this option is checked, ANTLR will turn on the computation and hoisting of "
 159                                 "predicate context."
 160                         },
 161                         /* [8] */
 162                         NotDependent { }, CheckOption {
 163                                 NotSet,
 164                                 {98, 25, 113, 225},
 165                                 "Don't generate Code",
 166                                 "-gc",
 167                                 "If this option is checked, ANTLR will generate no code, i.e. "
 168                                 "it will only perform analysis on the grammar."
 169                         },
 170                         /* [9] */
 171                         NotDependent { }, CheckOption {
 172                                 NotSet,
 173                                 {78, 235, 93, 435},
 174                                 "Don't create Lexer files",
 175                                 "-gx",
 176                                 "If this option is checked, ANTLR will not generate DLG-related output files. "
 177                                 "This option should be used if one wants a custom lexical analyzer or if one "
 178                                 "has made changes to the grammar not affecting the lexical structure."
 179                         },
 180                         /* [10] */
 181                         NotDependent { }, CheckOption {
 182                                 NotSet,
 183                                 {118, 25, 133, 225},
 184                                 "Delay lookahead fetches",
 185                                 "-gk",
 186                                 "If this option is checked, ANTLR will generate a parser that delays lookahead "
 187                                 "fetches until needed."
 188                         },
 189                         /* [11] */
 190                         NotDependent { }, CheckOption {
 191                                 NotSet,
 192                                 {98, 235, 113, 460},
 193                                 "Don't generate token expr sets",
 194                                 "-gs",
 195                                 "If this option is checked, ANTLR will not generate sets for token expression "
 196                                 "sets; instead, it will generate a || separated sequence of LA(1)==token #. "
 197                         },
 198                         /* [12] */
 199                         NotDependent { }, RegularEntry {
 200                                 "Lookahead:",
 201                                 {140, 25, 155, 150},
 202                                 {160, 25, 176, 150},
 203                                 "1",
 204                                 keepCase,
 205                                 "-k",
 206                                 "This entry specifies the number of tokens of lookahead."
 207                         },
 208                         /* [13] */
 209                         NotDependent { }, RegularEntry {
 210                                 "Compr lookahead:",
 211                                 {140, 165, 155, 290},
 212                                 {160, 165, 176, 290},
 213                                 "",
 214                                 keepCase,
 215                                 "-ck",
 216                                 "This entry specifies the number of tokens of lookahead when using compressed "
 217                                 "(linear approximation) lookahead. In general, the compressed lookahead is much "
 218                                 "deeper than the full lookahead."
 219                         },
 220                         /* [14] */
 221                         NotDependent { }, RegularEntry {
 222                                 "Max tree nodes:",
 223                                 {140, 310, 155, 435},
 224                                 {160, 305, 176, 435},
 225                                 "",
 226                                 keepCase,
 227                                 "-rl",
 228                                 "This entry specifies the maximum number of tokens of tree nodes used by the grammar "
 229                                 "analysis."
 230                         }
 231                 },
 232                 /* [3] */
 233                 295,
 234                 "Use this dialog to specify still more command line options.",
 235                 {
 236                         /* [1] */
 237                         NotDependent { }, RadioButtons {
 238                                 {       /* array radioArray: 3 elements */
 239                                         /* [1] */
 240                                         {38, 25, 53, 105}, "None", "", Set, "When this option is selected, ANTLR "
 241                                         "will not print the grammar to stdout.",
 242                                         /* [2] */
 243                                         {38, 115, 53, 195}, "Yes", "-p", NotSet, "When this option is selected, ANTLR "
 244                                         "will print the grammar, stripped of all actions and comments, to stdout.",
 245                                         /* [3] */
 246                                         {38, 210, 53, 300}, "More", "-pa", NotSet, "When this option is selected, ANTLR "
 247                                         "will print the grammar, stripped of all actions and comments, to stdout. "
 248                                         "It will also annotate the output with the first sets determined from grammar "
 249                                         "analysis."
 250                                 }
 251                         },
 252                         /* [2] */
 253                         NotDependent { }, TextBox {
 254                                 gray,
 255                                 { 28, 15, 60, 310 },
 256                                 "Grammar Printing"
 257                         },
 258                         /* [3] */
 259                         NotDependent { }, RadioButtons {
 260                                 {       /* array radioArray: 3 elements */
 261                                         /* [1] */
 262                                         {88, 25, 103, 105}, "Low", "", Set, "When this option is selected, ANTLR "
 263                                         "will show ambiguities/errors in low detail.",
 264                                         /* [2] */
 265                                         {88, 115, 103, 195}, "Medium", "-e2", NotSet, "When this option is selected, ANTLR "
 266                                         "will show ambiguities/errors in more detail.",
 267                                         /* [3] */
 268                                         {88, 210, 103, 300}, "High", "-e3", NotSet, "When this option is selected, ANTLR "
 269                                         "will show ambiguities/errors in excruciating detail."
 270                                 }
 271                         },
 272                         /* [4] */
 273                         NotDependent { }, TextBox {
 274                                 gray,
 275                                 { 78, 15, 110, 310 },
 276                                 "Error reporting"
 277                         },
 278                         /* [5] */
 279                         NotDependent { }, CheckOption {
 280                                 NotSet,
 281                                 {128, 25, 143, 225},
 282                                 "More warnings",
 283                                 "-w2",
 284                                 "If this option is checked, ANTLR will warn if semantic predicates and/or "
 285                                 "(É)? blocks are assumed to cover ambiguous alternatives."
 286                         },
 287
 288                 },
 289                 /* [4] */
 290                 295,
 291                 "Use this dialog to specify command line options relating to renaming output files.",
 292                 {
 293                         /* [1] */
 294                         NotDependent { }, RegularEntry {
 295                                 "Errors file name:",
 296                                 {35, 25, 50, 205},
 297                                 {35, 205, 51, 300},
 298                                 "err.c",
 299                                 keepCase,
 300                                 "-fe",
 301                                 "This entry specifies the name ANTLR uses for "
 302                                 "the errors file."
 303                         },
 304                         /* [2] */
 305                         NotDependent { }, RegularEntry {
 306                                 "Lexical output name:",
 307                                 {60, 25, 75, 205},
 308                                 {60, 205, 76, 300},
 309                                 "parser.dlg",
 310                                 keepCase,
 311                                 "-fl",
 312                                 "This entry specifies the name ANTLR uses for "
 313                                 "the lexical output file."
 314                         },
 315                         /* [3] */
 316                         NotDependent { }, RegularEntry {
 317                                 "Lexical modes name:",
 318                                 {85, 25, 100, 205},
 319                                 {85, 205, 101, 300},
 320                                 "mode.h",
 321                                 keepCase,
 322                                 "-fl",
 323                                 "This entry specifies the name ANTLR uses for "
 324                                 "the lexical mode definitions file."
 325                         },
 326                         /* [4] */
 327                         NotDependent { }, RegularEntry {
 328                                 "Remap file name:",
 329                                 {110, 25, 125, 205},
 330                                 {110, 205, 126, 300},
 331                                 "remap.h",
 332                                 keepCase,
 333                                 "-fl",
 334                                 "This entry specifies the name ANTLR uses for "
 335                                 "the file that remaps globally visible symbols."
 336                         },
 337                         /* [5] */
 338                         NotDependent { }, RegularEntry {
 339                                 "Tokens file name:",
 340                                 {135, 25, 150, 205},
 341                                 {135, 205, 151, 300},
 342                                 "tokens.h",
 343                                 keepCase,
 344                                 "-fl",
 345                                 "This entry specifies the name ANTLR uses for "
 346                                 "the tokens file."
 347                         },
 348                         /* [6] */
 349                         NotDependent{ }, CheckOption {
 350                                 NotSet,
 351                                 {160, 25, 175, 175},
 352                                 "Create std header",
 353                                 "-gh",
 354                                 "If this option is checked, ANTLR will create a standard header file named, "
 355                                 "by default 'stdpccts.h'. This name can be altered using the entry right next door."
 356                         },
 357                         /* [7] */
 358                         Or { {6} }, RegularEntry {
 359                                 "Std header file name:",
 360                                 {160, 175, 175, 355},
 361                                 {160, 355, 176, 450},
 362                                 "stdpccts.h",
 363                                 keepCase,
 364                                 "-fh",
 365                                 "This entry specifies the name ANTLR uses for "
 366                                 "the standard header file."
 367                         }
 368                 }
 369         }
 370 };
 371