BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg.r

   1 /*
   2         File:           dlgMPW.r
   3         Target:         dlg 133MR
   4         Created:    Monday, June 15, 1998 4:44:11 AM
   5         Author:         Kenji Tanaka (kentar@osa.att.ne.jp)
   6 */
   7
   8 #include "cmdo.r"
   9
  10 resource 'cmdo' (128, "Dlg") {
  11         {       /* array dialogs: 1 elements */
  12                 /* [1] */
  13                 295,
  14                 "DLG -- Purdue Compiler Construction Tool"
  15                 " Set (PCCTS) lexical analyzer generator.",
  16                 {       /* array itemArray: 18 elements */
  17                         /* [1] */
  18                         NotDependent {
  19
  20                         },
  21                         CheckOption {
  22                                 NotSet,
  23                                 {35, 175, 50, 225},
  24                                 "On",
  25                                 "-CC",
  26                                 "When this control is checked, DLG generates "
  27                                 "a scanner using C++ classes rather than "
  28                                 "C functions."
  29                         },
  30                         /* [2] */
  31                         Or {
  32                                 {       /* array OrArray: 1 elements */
  33                                         /* [1] */
  34                                         1
  35                                 }
  36                         },
  37                         RegularEntry {
  38                                 "Lexer Class Name:",
  39                                 {35, 225, 50, 355},
  40                                 {35, 355, 51, 450},
  41                                 "DLGLexer",
  42                                 keepCase,
  43                                 "-cl",
  44                                 "This entry specifies the name DLG uses for the C++ lexer class."
  45                         },
  46                         /* [3] */
  47                         NotDependent {
  48
  49                         },
  50                         TextBox {
  51                                 gray,
  52                                 {25, 165, 60, 460},
  53                                 "C++ Code Generation"
  54                         },
  55                         /* [4] */
  56                         NotDependent {
  57
  58                         },
  59                         Files {
  60                                 InputFile,
  61                                 RequiredFile {
  62                                         {37, 25, 56, 135},
  63                                         "Input File",
  64                                         "",
  65                                         "Choose the lexical description file for "
  66                                         "DLG to process."
  67                                 },
  68                                 Additional {
  69                                         "",
  70                                         "",
  71                                         "",
  72                                         "",
  73                                         {       /* array TypesArray: 1 elements */
  74                                                 /* [1] */
  75                                                 text
  76                                         }
  77                                 }
  78                         },
  79                         /* [5] */
  80                         Or {
  81                                 {       /* array OrArray: 1 elements */
  82                                         /* [1] */
  83                                         -1
  84                                 }
  85                         },
  86                         Files {
  87                                 OutputFile,
  88                                 RequiredFile {
  89                                         {66, 25, 85, 135},
  90                                         "Output File",
  91                                         "",
  92                                         "Choose the name of the file that will hold the DLG-produced scanner."
  93                                 },
  94                                 NoMore {
  95
  96                                 }
  97                         },
  98                         /* [6] */
  99                         Or {
 100                                 {       /* array OrArray: 2 elements */
 101                                         /* [1] */
 102                                         1,
 103                                         /* [2] */
 104                                         5
 105                                 }
 106                         },
 107                         Dummy {
 108
 109                         },
 110                         /* [7] */
 111                         NotDependent {
 112
 113                         },
 114                         Redirection {
 115                                 DiagnosticOutput,
 116                                 {90, 25}
 117                         },
 118                         /* [8] */
 119                         NotDependent {
 120
 121                         },
 122                         TextBox {
 123                                 gray,
 124                                 {25, 20, 132, 145},
 125                                 "Files"
 126                         },
 127                         /* [9] */
 128                         NotDependent {
 129
 130                         },
 131                         Files {
 132                                 DirOnly,
 133                                 OptionalFile {
 134                                         {68, 175, 84, 305},
 135                                         {88, 175, 107, 305},
 136                                         "Output Directory",
 137                                         ":",
 138                                         "-o",
 139                                         "",
 140                                         "Choose the directory where DLG will put "
 141                                         "its output.",
 142                                         dim,
 143                                         "Output DirectoryI",
 144                                         "",
 145                                         ""
 146                                 },
 147                                 NoMore {
 148
 149                                 }
 150                         },
 151                         /* [10] */
 152                         NotDependent {
 153
 154                         },
 155                         RegularEntry {
 156                                 "Mode File Name:",
 157                                 {68, 315, 83, 450},
 158                                 {88, 315, 104, 450},
 159                                 "mode.h",
 160                                 keepCase,
 161                                 "-m",
 162                                 "This entry specifies the name DLG uses for its lexical mode output file."
 163                         },
 164                         /* [11] */
 165                         NotDependent {
 166
 167                         },
 168                         RadioButtons {
 169                                 {       /* array radioArray: 3 elements */
 170                                         /* [1] */
 171                                         {134, 175, 149, 255}, "None", "", Set, "When this option is selected, DLG will not "
 172                                         "compress its tables.",
 173                                         /* [2] */
 174                                         {134, 265, 149, 345}, "Level 1", "-C1", NotSet, "When this option is selected, DLG will "
 175                                         "remove all unused characters from the transition-from table.",
 176                                         /* [3] */
 177                                         {134, 360, 149, 450}, "Level 2", "-C2", NotSet, "When this option is selected, DLG will "
 178                                         "perform level 1 compression plus it will "
 179                                         "map equivalent characters into the same "
 180                                         "character classes."
 181                                 }
 182                         },
 183                         /* [12] */
 184                         NotDependent {
 185
 186                         },
 187                         TextBox {
 188                                 gray,
 189                                 {124, 165, 156, 460},
 190                                 "Table Compression"
 191                         },
 192                         /* [13] */
 193                         NotDependent {
 194
 195                         },
 196                         CheckOption {
 197                                 Set,
 198                                 {165, 20, 180, 145},
 199                                 "Case Sensitive",
 200                                 "-ci",
 201                                 "When this control is checked, the DLG automaton "
 202                                 "will treat upper and lower case "
 203                                 "characters identically."
 204                         },
 205                         /* [14] */
 206                         NotDependent {
 207
 208                         },
 209                         CheckOption {
 210                                 NotSet,
 211                                 {165, 150, 180, 300},
 212                                 "Interactive Scanner",
 213                                 "-i",
 214                                 "When this control is checked, DLG will generate "
 215                                 "as interactive a scanner as possible."
 216                         },
 217                         /* [15] */
 218                         NotDependent {
 219
 220                         },
 221                         CheckOption {
 222                                 NotSet,
 223                                 {165, 310, 180, 460},
 224                                 "Ambiguity Warnings",
 225                                 "-Wambiguity",
 226                                 "When this control is checked, DLG warns "
 227                                 "if more than one regular expression could "
 228                                 "match the same character sequence."
 229                         },
 230                         /* [16] */
 231                         NotDependent {
 232
 233                         },
 234                         VersionDialog {
 235                                 VersionString {
 236                                         "1.33MR"
 237                                 },
 238                                 "PCCTS was written by Terence Parr, Russell "
 239                                 "Quong, Will Cohen, and Hank Dietz: 1989-1998. "
 240                                 "MPW port by Scott Haney.",
 241                                 noDialog
 242                         },
 243                         /* [17] */
 244                         And {
 245                                 {       /* array AndArray: 2 elements */
 246                                         /* [1] */
 247                                         4,
 248                                         /* [2] */
 249                                         6
 250                                 }
 251                         },
 252                         DoItButton {
 253
 254                         },
 255                         /* [18] */
 256                         NotDependent {
 257
 258                         },
 259                         CheckOption {
 260                                 NotSet,
 261                                 {142, 20, 157, 148},
 262                                 "Generate ANSI C",
 263                                 "-ga",
 264                                 "When this control is checked, DLG generates "
 265                                 "ANSI C compatible code."
 266                         }
 267                 }
 268         }
 269 };
 270