eXept Software AG Logo

Smalltalk/X Webserver

Documentation of class 'ParserFlags':

Home

Documentation
www.exept.de
Everywhere
for:
[back]

Class: ParserFlags


Inheritance:

   Object
   |
   +--ParserFlags

Package:
stx:libcomp
Category:
System-Compiler
Version:
rev: 1.179 date: 2019/08/17 12:36:31
user: cg
file: ParserFlags.st directory: libcomp
module: stx stc-classLibrary: libcomp

Description:


compiler flags (used to be defined in Scanner and Parser) have been extracted for easier
individual-method customization (using ST as scripting).

The class side provides correspondingly-named variables, which hold the default values.

howTo_fileInVSE:
    ParserFlags allowSTVExtensions:true.
    ParserFlags allowSTVPrimitives:true.
    ParserFlags allowSTXEOLComments:false.

for stx debugging:
    STCKeepCIntermediate := true

the flags control:
    Warnings                            -- enable/disable any warnings from the compiler
      WarnUndeclared                    -- warn about undeclared variables
      WarnUnusedVars                    -- warn about unused variables
      WarnST80Directives                -- warn when ST80 (visualworks) directives (primitives) are used
      WarnAboutWrongVariableNames       -- conventions / style
      WarnAboutVariableNameConventions 
      WarnAboutNonLowercaseLocalVariableNames
      WarnAboutShortLocalVariableNames
      WarnAboutBadComments 
      WarnCommonMistakes
      WarnAboutReferenceToPrivateClass
    WarnPossibleIncompatibilities
      WarnSTXSpecials                   -- warn when special ST/X syntax extensions are used
      WarnUnderscoreInIdentifier        -- underscores in identifier (not all Smalltalk dialects support this)
      WarnDollarInIdentifier            -- dollar in identifier (not all Smalltalk dialects support this)
      WarnParagraphInIdentifier         -- paragraph character in identifier
      WarnOldStyleAssignment            -- assignment with _ - character
      WarnHiddenVariables               -- locals shadowing outer/instvars
      WarnInconsistentReturnValues      -- boolean/non-boolean return values
      WarnAboutPeriodInSymbol
      WarnAboutPossibleSTCCompilationProblems
      WarnAboutUnknownCharacterEscapesInJavaScriptStringConstant
      WarnAssignmentToBlockArgument 
      WarnAssignmentToMethodArgument
      WarnAssignmentToPoolVariable
    WarnPlausibilityChecks
      WarnAboutPossiblyUnimplementedSelectors

   AllowReservedWordsAsSelectors
   AllowUnderscoreInIdentifier 
   AllowParagraphInIdentifier 
   AllowDollarInIdentifier              -- st80-vms dollars in identifiers
   AllowOldStyleAssignment              -- st80 underscore as assignment
   AllowDolphinExtensions               -- dolphin computed literal
   AllowQualifiedNames                  -- vw3 qualified names
   AllowExtendedBinarySelectors         -- vw5.4 extended binary selectors (plus/minus, center-dot etc.)
   AllowCaretAsBinop                    -- too dangerous
   AllowLiteralNameSpaceSymbols         -- st/x literal nameSpace-symbols (#foo::bar)
   AllowArrayIndexSyntaxExtension 
   AllowFunctionCallSyntaxForBlockEvaluation 
   AllowLocalVariableDeclarationWithInitializerExpression 
   AllowDomainVariables 
   AllowArrayIndexSyntaxExtension 
   AllowReservedWordsAsSelectors 
   AllowVariableReferences 
   AllowLazyValueExtension 
   AllowFixedPointLiterals 
   AllowExtendedSTXSyntax 
   AllowVisualAgeESSymbolLiterals 
   AllowExtensionsToPrivateClasses 
   AllowVisualAgePrimitives 
   AllowSqueakExtensions                -- squeak computed array
   AllowSqueakPrimitives 
   AllowSTVPrimitives                   -- number-sign syntax
   AllowSTVExtensions 
   AllowNationalCharactersInIdentifier 
   AllowHashAsBinarySelector 
   AllowSTXEOLComments                  -- DQuote/ EOL comments
   AllowSTXDelimiterComments            -- DQuote<<END delimiter comments
   AllowVisualWorksMethodAnnotations 
   AllowPossibleSTCCompilationProblems  -- must be true, to allow fileIn
   AllowEmptyStatements 
   AllowPeriodInSymbol 
   AllowPeriodAsNameSpaceSeparator 

   AllowCStrings                        -- c'....' is a string with C-escapes
   AllowUnicodeStrings 
   AllowUnicodeCharacters 
   AllowCharacterEscapes 
   AllowStringEscapes 
   AllowAssignmentToBlockArgument 
   AllowAssignmentToMethodArgument 
   AllowAssignmentToPoolVariable 
   AllowSignedByteArrayElements 
   AllowSymbolsStartingWithDigit 

   AllowJavaScriptConst               

   ArraysAreImmutable                 -- still care for ST-80 compatibility
   StringsAreImmutable                -- still care for ST-80 compatibility
   ImplicitSelfSends 



Class protocol:

accessing-compilation control
o  allowExtensionsToPrivateClasses

o  allowExtensionsToPrivateClasses: aBoolean

o  allowPossibleSTCCompilationProblems
self allowPossibleSTCCompilationProblems:true
self allowPossibleSTCCompilationProblems:false

self warnAboutPossibleSTCCompilationProblems

o  allowPossibleSTCCompilationProblems: aBoolean

o  arraysAreImmutable
return true if arrays and byteArrays are compiled as immutable literals

o  arraysAreImmutable: aBoolean
turn on/off immutable array and byteArrays literals - default is false for ST-80 compatibilty.

usage example(s):

     can be added to your private.rc file:

     ParserFlags arraysAreImmutable:true
     ParserFlags arraysAreImmutable:false

o  fullLineNumberInfo

o  implicitSelfSends
return true if undefined variables with
lowercase first character are to be turned
into implicit self sends

o  implicitSelfSends: aBoolean
turn on/off implicit self sends

usage example(s):

     Compiler implicitSelfSends:true
     Compiler implicitSelfSends:false

o  lineNumberInfo

o  lineNumberInfo: aSymbol

o  singlePrecisionFloatF
by default, the 'f'-character in a float literal will generate
double-precision Float literals.
With allowSinglePrecisionFloats, it will generate single precision ShortFloat literals.
The default is false.
Notice, that there is some confusion among Smalltalk systems, whether a float has
single or double precision (VW vs. V'age).
In ST/X, floats have double-precision by default.

o  singlePrecisionFloatF: aBoolean
by default, the 'f'-character in a float literal will generate
double-precision Float literals.
With allowSinglePrecisionFloats, it will generate single precision ShortFloat literals.
The default is false.
Notice, that there is some confusion among Smalltalk systems, whether a float has
single or double precision (VW vs. V'age).
In ST/X, floats have double-precision by default.

o  stringsAreImmutable
return true if strings are immutable literals

o  stringsAreImmutable: aBoolean
turn on/off immutable string literals - default is false for ST-80 compatibilty.

usage example(s):

     can be added to your private.rc file:

     ParserFlags stringsAreImmutable:true
     ParserFlags stringsAreImmutable:false

accessing-per method flags
o  disableFlag: flagName forClass: class selector: selector
remember that warnings named flagName (such as #warnUnusedVars)
are disabled for a particular method.
Sent if user wants to disable warnings in the future
(try defining a method with an unused var, to see)

o  isFlag: flagName enabledForClass: class selector: selector
return true, if warnings named <flagName> (such as #warnUnusedVars)
are to be suppressed for a particular method.

o  perMethodDisableWarningTimeDuration
when the user wants to suppress a particular warning for a particular
method, it will be only suppressed for some time duration.
After that, the suppress will automatically be removed, and normal warnings
are issued again.

o  reenableAllSuppressedFlags
turn off any suppressed warnings

accessing-stc compilation control
o  bccTop: aPath
windows only: define the borland-C installation directory.
must contain bin\bcc32.exe and include.
Typically, something like 'C:\borland\bcc55'

o  ccCompilationOptions

o  ccCompilationOptions: aString

o  ccPath

o  ccPath: aSymbol

o  libDirectory

o  libDirectory: aString

o  libPath

o  libPath: aString

o  linkArgs

o  linkArgs: aString

o  linkCommand

o  linkCommand: aString

o  linkSharedArgs

o  linkSharedArgs: aString
Modified (format): / 28-02-2012 / 13:34:58 / cg

o  makeCommand

o  makeCommand: aString

o  sdkTop: aPath
windows only: define the SDK top directory.
must include folder with windows header files.
Typically something like 'C:\Program Files\Microsoft SDKs\Windows\v6.0A'

o  searchedLibraries

o  searchedLibraries: aString

o  stcCompilation

o  stcCompilation: aSymbol

o  stcCompilationDefines

o  stcCompilationDefines: aString

o  stcCompilationIncludes

o  stcCompilationIncludes: aString

o  stcCompilationOptions

o  stcCompilationOptions: aString

o  stcKeepCIntermediate

o  stcKeepCIntermediate: aBoolean
STCKeepCIntermediate := true.
STCKeepCIntermediate := false.

o  stcKeepOIntermediate

o  stcKeepOIntermediate: aBoolean
STCKeepOIntermediate := true.
STCKeepOIntermediate := false.

o  stcKeepSTIntermediate
STCKeepSTIntermediate := true.
STCKeepSTIntermediate := false.

o  stcKeepSTIntermediate: aBoolean
STCKeepSTIntermediate := true.
STCKeepSTIntermediate := false.

o  stcModulePath
the folder, where temporarily compiled modules are created by stc.
Used to be inside the bin-directory, but that did not work for readonly/shared
st/x installations (i.e. running stx from a mounted dbg).
Therefore, this is now in the workspace (where the snapshot image resudes as well)

Notice:
this ought to be a persistent folder (at least as along as any
snapshot image is present, which refers to any module there.
As we cannot (currently) scan snapshots, this is somewhat tricky.

o  stcModulePath: aPath
set the path to the directory, where temporary modules are created.
Obsolete now, as this should not be set from the outside,
but instead rely totally on the userPreferences.

o  stcPath

o  stcPath: aPath

o  useBorlandC
true if borland compiler should be used

o  useClang
true if clang compiler should be used

o  useCompilerDefine: aCompilerDefine
enforce a particular compiler to be used (independent from
what the system was compiled with)

o  useGnuC
true if gnu-c compiler should be used

o  useMingw32
true if mingw compiler should be used

o  useMingw64
true if mingw compiler should be used

o  useVisualC
true if visual-c compiler should be used

o  usedCompiler
dfn = DefineForLCC ifTrue:[ ^'lcc'].

usage example(s):

     self usedCompiler

o  usedCompilerDefine
return the define to be used for the compiler toolchain.
By default, the toolchain with which stx itself was compiled is used (getCCDefine);
can be overwritten by setting ForcedCompiler

usage example(s):

     ForcedCompiler := DefineForCLANG.
     self usedCompilerDefine.
     
     ForcedCompiler := nil.
     self usedCompilerDefine.

o  vcTop: aPath
windows only: define the visual-C top directory.
must contain bin\cl.exe and include.
Typically, something like 'C:\Program Files\Microsoft Visual Studio 10.0\VC'

o  withSTCCompilation: howSymbol do: aBlock

accessing-syntax-control
o  allowArrayIndexSyntaxExtension
experimental syntax: var[idx-expr]

usage example(s):

     self allowArrayIndexSyntaxExtension:true
     self allowArrayIndexSyntaxExtension:false
     self allowArrayIndexSyntaxExtension

o  allowArrayIndexSyntaxExtension: aBoolean
experimental syntax: var[idx-expr]

usage example(s):

     self allowArrayIndexSyntaxExtension:true
     self allowArrayIndexSyntaxExtension:false

o  allowAssignmentToBlockArgument

o  allowAssignmentToBlockArgument: aBoolean

o  allowAssignmentToMethodArgument

o  allowAssignmentToMethodArgument: aBoolean

o  allowAssignmentToPoolVariable

o  allowAssignmentToPoolVariable: aBoolean

o  allowCIntegers
allow c-style integers of the form: 0xHHH, 0bBBB and 0oOOO

o  allowCIntegers: aBoolean
allow c-style integers of the form: 0xHHH, 0bBBB and 0oOOO

usage example(s):

     ParserFlags allowCIntegers:true
     ParserFlags allowCIntegers

o  allowCStrings
allow c-style strings of the form:
c'...' containing c-language character escapes

o  allowCStrings: aBoolean
allow c-style strings of the form:
c'...' containing c-language character escapes

usage example(s):

     ParserFlags allowCStrings:true
     ParserFlags allowCStrings

o  allowCaretAsBinop
allow '^' to be used as a binary operator

o  allowCaretAsBinop: aBoolean
allow '^' to be used as a binary operator

o  allowDollarInIdentifier
return true, if $-characters are allowed in identifiers.
Notice, that dollars are NEVER allowed as the first character in an identifier
(because they are interpreted as character-constant then).
Dollars in identifiers were used in VMS versions of VW-Smalltalk

o  allowDollarInIdentifier: aBoolean
this allows turning on/off $-characters in identifiers.
Notice, that dollars are NEVER allowed as the first character in an identifier.
If turned off (the default), dollars are not allowed in identifiers,
but instead are scanned as character-constant prefix.
If turned on, dollars in identifiers are allowed, while extra
dollars are still scanned as constant character prefix.
If you have to fileIn old VW-Vsn2.x classes, turn this off
before filing them in; i.e.:
Compiler allowDollarInIdentifiers:false
Dollars in identifiers were used in VMS versions of VW-Smalltalk.

o  allowDolphinExtensions
return true, if ##(..) computed literals are allowed

o  allowDolphinExtensions: aBoolean
this allows turning on/off support for computed arrays ##(..) as in dolphin.
If you want to fileIn Dolphin classes, enable this with:
Compiler allowDolphinComputedArrays:true

usage example(s):

     self allowDolphinExtensions:true
     self allowDolphinExtensions:false

o  allowEStrings
allow extended strings with embedded expressions of the form:
e'...' containing c-language character escapes
and embedded expressions {expr} which are sliced in

o  allowEStrings: aBoolean
allow extended strings with embedded expressions of the form:
e'...' containing c-language character escapes
and embedded expressions {expr} which are sliced in

o  allowEmptyStatements
return true, if empty statements are allowed (two .'s in a row).
Notice, that stc cannot (yet) handle those.

o  allowEmptyStatements: aBoolean
turn on/off, if empty statements are allowed (two .'s in a row).
Notice, that stc cannot (yet) handle those.

o  allowExtendedBinarySelectors
experimental extended selectors extensions

usage example(s):

     ParserFlags allowExtendedBinarySelectors
     ParserFlags allowExtendedBinarySelectors:false
     ParserFlags allowExtendedBinarySelectors:true

o  allowExtendedBinarySelectors: aBoolean
experimental syntax extensions

o  allowExtendedSTXSyntax
Enables ALL of the ST/X extensions.
Do not use for now, as stc does not support all of them

o  allowExtendedSTXSyntax: aBoolean
Enables ALL of the ST/X extensions.
Do not use for now, as stc does not support all of them

usage example(s):

     self allowExtendedSTXSyntax:true
     'a\tb' inspect.
     'a\u1616b' inspect.
     self allowExtendedSTXSyntax:false

o  allowFixedPointLiterals
return true, if nnnsn (FixedPoint) literals are allowed.
The default is true.

o  allowFixedPointLiterals: aBoolean
enable/disable, if nnnsn (FixedPoint) literals are allowed.
The default is true.

o  allowFunctionCallSyntaxForBlockEvaluation
experimental

o  allowFunctionCallSyntaxForBlockEvaluation: aBoolean
experimental

o  allowGreekCharactersInIdentifier
return true, if greek characters (alpha, beta etc.) are allowed in identifiers

o  allowGreekCharactersInIdentifier: aBoolean
are greek characters (alpha, beta etc.) are allowed in identifiers.
Use this ONLY to file in some non-ANSI ST code

o  allowHashAsBinarySelector
if true, a free-standing single '#' is allowed as a binary selector.
The default is true.

o  allowHashAsBinarySelector: aBoolean
if true, a free-standing single '#' is allowed as a binary selector.
The default is true.

usage example(s):

     self allowHashAsBinarySelector:true
     self allowHashAsBinarySelector:false
     123 # 234

o  allowJavaScriptConst
return true, if const is allowed and treated as a keyword (in JavaScript)

o  allowJavaScriptConst: aBoolean
true, if const is allowed and treated as a keyword (in JavaScript)

o  allowLazyValueExtension
allow ![...] to generate a lazy value

o  allowLazyValueExtension: aBoolean
allow ![...] to generate a lazy value

o  allowLiteralNameSpaceSymbols
return true, if literal nameSpace symbols are allowed (#foo::bar) are allowed

o  allowLiteralNameSpaceSymbols: aBoolean
controls, if literal nameSpace symbols are allowed (#foo::bar) are allowed

o  allowLocalVariableDeclarationWithInitializerExpression
experimental: | var := expr |

usage example(s):

     self allowLocalVariableDeclarationWithInitializerExpression:true
     self allowLocalVariableDeclarationWithInitializerExpression:false

     |a := 0 . b := 1 |
     Transcript showCR:'a is',a,' b is ',b

o  allowLocalVariableDeclarationWithInitializerExpression: aBoolean
experimental: | var := expr |

o  allowNationalCharactersInIdentifier
return true, if national characters (diaresis etc.) are allowed in identifiers

o  allowNationalCharactersInIdentifier: aBoolean
this allows turning on/off recognition of national characters (diaresis etc.) in identifiers.
Use this ONLY to file in some non-ANSI ST/V code

usage example(s):

     ParserFlags allowNationalCharactersInIdentifier:true

o  allowOldStyleAssignment
return true, if underscore-assignment (pre ST-80v4 syntax) are to be allowed

o  allowOldStyleAssignment: aBoolean
this allows turning on/off recognition of underscore-assignment (pre ST-80v4 syntax).
You must turn this off, if code with variables named '_' is to be filedIn

o  allowParagraphInIdentifier
return true, if §-characters are allowed in identifiers (treated as letter)

o  allowParagraphInIdentifier: aBoolean
this allows turning on/off §-characters in identifiers.

o  allowPeriodInSymbol
return true, if periods are allowed in a symbol literal #foo.bar.
Needed to parse some old ST80/Squeak code

o  allowPeriodInSymbol: aBoolean
control, if periods are allowed in a symbol literal #foo.bar.
Needed to parse some old ST80/Squeak code

usage example(s):

     self allowPeriodInSymbol:true.
     self assert:( Parser parseExpression:' #foo.bar.baz. ' ) value == #'foo.bar.baz'.

     self allowPeriodInSymbol:false.
     self assert:( Parser parseExpression:' #foo.bar.baz. ' ) value == #'foo'.

o  allowQualifiedNames
return true, if '#{..}' and 'namespace.varName' qualified names are allowed

o  allowQualifiedNames: aBoolean
this allows turning on/off support for qualifiedNames #{ .., } as in vw3.
If you want to fileIn vw3 or later classes, enable this with:
Compiler allowQualifiedNames:true
Notice, that qualified names are not really supported semantically
(they are parsed, but treated like regular globals)

usage example(s):

     self allowQualifiedNames:true
     self allowQualifiedNames:false

o  allowRStrings
rstrings have the syntax:
r'...'
which generates a regex

o  allowRStrings: aBoolean
rstrings have the syntax:
r'...'
which generates a regex

o  allowReservedWordsAsSelectors
if true, 'self', 'super', 'thisContext', 'nil', 'true' and 'false' are allowed
as unary message selectors.

o  allowReservedWordsAsSelectors: aBoolean
enable/disable, if 'self', 'super', 'thisContext', 'nil', 'true' and 'false' are to be allowed
as unary message selectors.

usage example(s):

     self allowReservedWordsAsSelectors:true
     self allowReservedWordsAsSelectors:false

o  allowSTVExtensions
return true, if support for ST/V syntax extensions is enabled.

o  allowSTVExtensions: aBoolean
this allows turning on/off support for ST/V extensions:
If you want to fileIn ST/V classes, enable this with:
Compiler allowSTVComputedArrays:true

usage example(s):

     ParserFlags allowSTVExtensions:true
     ParserFlags allowSTVExtensions:false

o  allowSTVPrimitives
return true, if support for ST/V primitives is enabled.

o  allowSTVPrimitives: aBoolean
this allows turning on/off support for ST/V primitives

usage example(s):

     ParserFlags allowSTVPrimitives:true

o  allowSTXDelimiterComments
token delimited comments;
these are multiline comments of the form:
''>>TOKEN
... anything, including double quotes
TOKEN>>''
(the '' being a double quote in the above)
Such comments are especially useful to comment pieces of sample code, which may
contain another comment in it, but you don't want to make them all EOL comments
(which are an ST/X speciality also, by the way).
Be aware, that no other smalltalk supports this, so your code becomes harder to port, if you use it.

o  allowSTXDelimiterComments: aBoolean
enable token delimited comments;
these are multiline comments of the form:
''>>TOKEN
... anything, including double quotes
TOKEN>>''
(the '' being a double quote in the above)
Such comments are especially useful to comment pieces of sample code, which may
contain another comment in it, but you don't want to make them all EOL comments
(which are an ST/X speciality also, by the way).
Be aware, that no other smalltalk supports this, so your code becomes harder to port, if you use it.

usage example(s):

     self allowSTXDelimiterComments:true
     self allowSTXDelimiterComments:false

o  allowSTXEOLComments
are ST/X end-of-line comments allowed?

o  allowSTXEOLComments: aBoolean
are ST/X end-of-line comments allowed?

usage example(s):

     self allowSTXEOLComments:true
     self allowSTXEOLComments:false

o  allowSTXExtendedArrayLiterals
are scheme-style typed literal arrays allowed?

o  allowSTXExtendedArrayLiterals: aBoolean
are scheme-style typed literal arrays allowed?

usage example(s):

     self allowSTXExtendedArrayLiterals:true
     self allowSTXExtendedArrayLiterals:false

o  allowSignedByteArrayElements
return true, if byteArray elements are allowed to be negative.

o  allowSignedByteArrayElements: aBoolean
controls, if byteArray elements are allowed to be negative.

o  allowSqueakExtensions
return true, if support for squeak extensions
computed arrays { .., }
c/java style arguments in message sends rec foo(arg1, ... argN)
is enabled.

o  allowSqueakExtensions: aBoolean
this allows turning on/off support for squeak extensions:
computed arrays { .., }
c/java style arguments in message sends rec foo(arg1, ... argN)

If you want to fileIn Squeak classes, enable this with:
Compiler allowSqueakComputedArrays:true

usage example(s):

     self allowSqueakExtensions:true
     self allowSqueakExtensions:false

o  allowSqueakPrimitives
return true, if support for squeak primitives is enabled.

o  allowSqueakPrimitives: aBoolean
this allows turning on/off support for squeak primitives

o  allowSymbolsStartingWithDigit
return true, if a symbol is allowed to start with a digit
i.e. as in #2D.
This seems to be ok in new Squeak/Pharo versions

o  allowSymbolsStartingWithDigit: aBoolean
controls if a symbol is allowed to start with a digit
i.e. as in #2D.
This seems to be ok in new Squeak/Pharo versions

o  allowUnderscoreInIdentifier
return true, if underscores are allowed in identifiers

o  allowUnderscoreInIdentifier: aBoolean
this allows turning on/off underscores in identifiers.
If turned off (the default), underscores are not allowed in identifiers,
but instead scanned as assignment character (old ST/80 syntax).
If turned on, underscores are in identifiers are allowed, while extra
underscores are still scanned as assignment.
If you have to fileIn old VW-Vsn2.x classes,
turn them off with:
Compiler allowUnderscoreInIdentifiers:false

o  allowUnicodeCharacters

o  allowUnicodeCharacters: aBoolean

o  allowUnicodeStrings

o  allowUnicodeStrings: aBoolean

o  allowVisualAgeESSymbolLiterals
return true, if ##symbols are allowed (treated like symbols)

o  allowVisualAgeESSymbolLiterals: aBoolean
if on, visualAge's ##symbols are allowed (treated like symbols)

o  allowVisualAgePrimitives
return true, if support for V'Age primitives is enabled.

o  allowVisualAgePrimitives: aBoolean
this allows turning on/off support for V'Age primitives

o  allowVisualWorksMethodAnnotations
return true, if support for V'Works extended primitive syntax for method annotations.

o  allowVisualWorksMethodAnnotations: aBoolean
turn on/off support for V'Works extended primitive syntax for method annotations.

o  warnAssignmentToBlockArgument

o  warnAssignmentToBlockArgument: aBoolean

o  warnAssignmentToMethodArgument

o  warnAssignmentToMethodArgument: aBoolean

o  warnAssignmentToPoolVariable

o  warnAssignmentToPoolVariable: aBoolean

accessing-warning-control
o  warnAboutBadComments
controls generation of warning messages about empty comments

o  warnAboutBadComments: aBoolean
controls generation of warning messages about empty comments

o  warnAboutNonLowercaseLocalVariableNames
controls generation of warning messages about wrong variable names

o  warnAboutNonLowercaseLocalVariableNames: aBoolean
controls generation of warning messages about wrong variable names

o  warnAboutPeriodInSymbol

o  warnAboutPeriodInSymbol: aBoolean

o  warnAboutPossibleNameClashes

o  warnAboutPossibleNameClashes: aBoolean

o  warnAboutPossibleSTCCompilationProblems

o  warnAboutPossibleSTCCompilationProblems: aBoolean

o  warnAboutPossiblyUnimplementedSelectors

o  warnAboutPossiblyUnimplementedSelectors: aBoolean

o  warnAboutPossiblyUninitializedLocals

o  warnAboutPossiblyUninitializedLocals: aBoolean

o  warnAboutReferenceToPrivateClass
controls generation of warning messages when a private class is referenced

o  warnAboutReferenceToPrivateClass: aBoolean
controls generation of warning messages when a private class is referenced

o  warnAboutShortLocalVariableNames
controls generation of warning messages about short variable names

o  warnAboutShortLocalVariableNames: aBoolean
controls generation of warning messages about short variable names

o  warnAboutUnknownCharacterEscapesInJavaScriptStringConstant
things like '\c:foo' instead of '\\c:foo'

o  warnAboutUnknownCharacterEscapesInJavaScriptStringConstant: aBoolean
things like '\c:foo' instead of '\\c:foo'

o  warnAboutVariableNameConventions
controls generation of warning messages about wrong variable names

o  warnAboutVariableNameConventions: aBoolean
controls generation of warning messages about wrong variable names

o  warnAboutWrongVariableNames
controls generation of warning messages about wrong variable names

o  warnAboutWrongVariableNames: aBoolean
controls generation of warning messages about wrong variable names

o  warnCommonMistakes
return true, if common beginners mistakes are to be warned about

o  warnCommonMistakes: aBoolean
this allows turning on/off warnings about common beginners mistakes.
Those are not really errors in the strict sense, but often lead to
run time errors later.
Examples are: expr or:expr2, where expr2 is not a block.
If you get bored by those warnings, turn them off by adding
a line as:
ParserFlags warnCommonMistakes:false
in your 'private.rc' file

o  warnDollarInIdentifier
return true, if $-characters in identifiers are to be warned about

o  warnDollarInIdentifier: aBoolean
this allows turning on/off warnings about $-characters in identifiers.
You may find those warnings useful, to make certain that your code
is portable to other Smalltalk versions, which do not allow this
(i.e. VW releases 2.x and maybe others).
Notice, that dollars are NEVER allowed as the first character in an identifier.
If you get bored by those warnings, turn them off by adding
a line as:
ParserFlags warnDollarInIdentifier:false
in your 'private.rc' file

o  warnHiddenVariables
controls generation of warning messages about hiding variables by locals

o  warnHiddenVariables: aBoolean
controls generation of warning messages about hiding variables by locals

o  warnInconsistentReturnValues
return true, if compiler should warn about inconsitent (boolean / non-boolean)
return values

o  warnInconsistentReturnValues: aBoolean
constrols if the compiler should warn about inconsitent (boolean / non-boolean)
return values

o  warnOldStyleAssignment
return true, if underscore-assignment (pre ST-80v4 syntax) are to be warned about

o  warnOldStyleAssignment: aBoolean
this allows turning on/off warnings about underscore-assignment (pre ST-80v4 syntax).
If you get bored by those warnings, turn them off by adding
a line as:
ParserFlags warnOldStyleAssignment:false
in your 'private.rc' file

o  warnParagraphInIdentifier
return true, if §-characters in identifiers are to be warned about

o  warnParagraphInIdentifier: aBoolean
this allows turning on/off warnings about §-characters in identifiers.
You may find those warnings useful, to make certain that your code
is portable to other Smalltalk versions, which do not allow this

o  warnPlausibilityChecks
controls generation of warning messages about plausibility checks (possible precedence, etc.)

o  warnPlausibilityChecks: aBoolean
controls generation of warning messages about plausibility checks (possible precedence, etc.)

o  warnPossibleIncompatibilities
return true, if possible incompatibilities (with other ST systems)
are to be warned about

o  warnPossibleIncompatibilities: aBoolean
this turns warnings about possible incompatibilities (with other ST systems)
on or off.
If you get bored by those warnings, turn them off by adding
a line as:
ParserFlags warnPossibleIncompatibilities:false
in your 'private.rc' file.

o  warnSTXSpecials
return true, if ST/X specials are to be warned about

o  warnSTXSpecials: aBoolean
this allows turning on/off warnings about stx specials.
If you get bored by those warnings, turn them off by adding
a line as:
ParserFlags warnSTXSpecials:false
in your 'private.rc' file

o  warnUnderscoreInIdentifier
return true, if underscores in identifiers are to be warned about

o  warnUnderscoreInIdentifier: aBoolean
this allows turning on/off warnings about underscores in identifiers.
You may find those warnings useful, to make certain that your code
is portable to other smalltalk versions, which do not allow this
(i.e. VW releases 2.x).
If you get bored by those warnings, turn them off by adding
a line as:
ParserFlags warnUnderscoreInIdentifier:false
in your 'private.rc' file

o  warnUnusedVars
controls generation of warning messages about unued method variables

o  warnUnusedVars: aBoolean
controls generation of warning messages about unued method variables

o  warnings
return true, if any warnings are to be shown

o  warnings: aBoolean
this allows turning on/off all warnings; the default is on.
You can turn off warnings in your 'private.rc' file with
ParserFlags warnings:false

usage example(s):

     ParserFlags warnings
     ParserFlags warnings:true
     ParserFlags warnings:false

class initialization
o  initialize
st80-vms dollars in identifiers

usage example(s):

     ParserFlags initialize

o  initializeSTCFlagsForTopDirectory: topDirArg
topDirArg must be the stx directory (where stc directory with stc-executable is found)
notice: for now, can only initialize for borland+windows or linux;
visualC setup still fails.

usage example(s):

     ParserFlags initializeSTCFlagsForTopDirectory:'../..'
     ParserFlags initialize

instance creation
o  new


Instance protocol:

accessing
o  fullLineNumberInfo

o  lineNumberInfo

o  lineNumberInfo: something

accessing-compilation control
o  allowExtensionsToPrivateClasses

o  allowExtensionsToPrivateClasses: aBoolean
attn: possibly sent via perform (Parser >> parsePragma)

o  allowPossibleSTCCompilationProblems

o  allowPossibleSTCCompilationProblems: aBoolean
attn: possibly sent via perform (Parser >> parsePragma)

o  arraysAreImmutable

o  arraysAreImmutable: aBoolean

o  flattenVisualWorksNamespaces

o  singlePrecisionFloatF
by default, the 'f'-character in a float literal will generate
double-precision Float literals.
With singlePrecisionFloats, it will generate single precision ShortFloat literals.
The default is false.
Notice, that there is some confusion among Smalltalk systems, whether a float has
single or double precision (VW vs. V'age).
In ST/X, floats have double-precision by default.

o  singlePrecisionFloatF: aBoolean
by default, the 'f'-character in a float literal will generate
double-precision Float literals.
With singlePrecisionFloats, it will generate single precision ShortFloat literals.
The default is false.
Notice, that there is some confusion among Smalltalk systems, whether a float has
single or double precision (VW vs. V'age).
In ST/X, floats have double-precision by default.

o  stringsAreImmutable

o  stringsAreImmutable: aBoolean

accessing-stc compilation control
o  ccCompilationOptions
self ccCompilationOptions

o  ccCompilationOptions: something

o  ccPath
self ccPath

o  ccPath: something

o  implicitSelfSends

o  implicitSelfSends: aBoolean

o  libPath
self libPath

o  libPath: aString

o  linkArgs
self linkArgs

o  linkArgs: aString

o  linkCommand
self new linkCommand

o  linkCommand: aString

o  linkSharedArgs

o  linkSharedArgs: aString

o  searchedLibraries

o  searchedLibraries: aString

o  stcCompilation

o  stcCompilation: something

o  stcCompilationDefines

o  stcCompilationDefines: something

o  stcCompilationIncludes
self stcCompilationIncludes

o  stcCompilationIncludes: something

o  stcCompilationOptions

o  stcCompilationOptions: something

o  stcKeepCIntermediate

o  stcKeepCIntermediate: something

o  stcKeepOIntermediate

o  stcKeepOIntermediate: something

o  stcKeepSIntermediate
^ true

o  stcKeepSTIntermediate

o  stcKeepSTIntermediate: something

o  stcModulePath

o  stcModulePath: aPath
set the path to the directory (for an individual compilation context).
Obsolete now, as this should not be set from the outside,
but instead rely totally on the userPreferences.

o  stcPath

o  stcPath: aPath

accessing-syntax-control
o  allowArrayIndexSyntaxExtension
experimental syntax: var[idx-expr]

o  allowArrayIndexSyntaxExtension: aBoolean
experimental syntax: var[idx-expr]

o  allowAssignmentToBlockArgument

o  allowAssignmentToBlockArgument: aBoolean
attn: possibly sent via perform (Parser >> parsePragma)

o  allowAssignmentToMethodArgument

o  allowAssignmentToMethodArgument: aBoolean
attn: possibly sent via perform (Parser >> parsePragma)

o  allowAssignmentToPoolVariable

o  allowAssignmentToPoolVariable: aBoolean
attn: possibly sent via perform (Parser >> parsePragma)

o  allowCIntegers
allow c-style integers of the form: 0xHHH, 0bBBB and 0oOOO

o  allowCIntegers: aBoolean
allow c-style integers of the form: 0xHHH, 0bBBB and 0oOOO

o  allowCStrings
cstrings have the syntax:
c'...'
where inside the string, c-language escapes are recognized

o  allowCStrings: aBoolean
cstrings have the syntax:
c'...'
where inside the string, c-language escapes are recognized

o  allowCaretAsBinop

o  allowCaretAsBinop: aBoolean
attn: possibly sent via perform (Parser >> parsePragma)

o  allowCharacterEscapes

o  allowCharacterEscapes: aBoolean
attn: possibly sent via perform (Parser >> parsePragma)

o  allowDollarInIdentifier

o  allowDollarInIdentifier: aBoolean
attn: possibly sent via perform (Parser >> parsePragma)

o  allowDolphinExtensions

o  allowDolphinExtensions: aBoolean
attn: possibly sent via perform (Parser >> parsePragma)

o  allowDomainVariables

o  allowDomainVariables: aBoolean
attn: possibly sent via perform (Parser >> parsePragma)

o  allowEStrings
estrings have the syntax:
e'...'
where inside the string, c-language escapes are recognized
AND embedded expressions {expr} are sliced into the string.

o  allowEStrings: aBoolean
estrings have the syntax:
e'...'
where inside the string, c-language escapes are recognized
AND embedded expressions {expr} are sliced into the string.

o  allowEmptyStatements

o  allowEmptyStatements: aBoolean
attn: possibly sent via perform (Parser >> parsePragma)

o  allowExtendedBinarySelectors

o  allowExtendedBinarySelectors: aBoolean
attn: possibly sent via perform (Parser >> parsePragma)

o  allowExtendedSTXSyntax
enables ALL of the ST/X extensions.
Do not use for now, as stc does not support all of them

o  allowExtendedSTXSyntax: aBoolean
enables ALL of the ST/X extensions.
Do not use for now, as stc does not support all of them

o  allowFixedPointLiterals

o  allowFixedPointLiterals: aBoolean
attn: possibly sent via perform (Parser >> parsePragma)

o  allowFunctionCallSyntaxForBlockEvaluation

o  allowFunctionCallSyntaxForBlockEvaluation: aBoolean
attn: possibly sent via perform (Parser >> parsePragma)

o  allowGreekCharactersInIdentifier

o  allowGreekCharactersInIdentifier: aBoolean
attn: possibly sent via perform (Parser >> parsePragma)

o  allowHashAsBinarySelector

o  allowJavaScriptConst
attn: possibly sent via perform (Parser >> parsePragma)

o  allowJavaScriptConst: aBoolean

o  allowLazyValueExtension
allow ![...] to generate a lazy value

o  allowLazyValueExtension: aBoolean
allow ![...] to generate a lazy value

o  allowLiteralNameSpaceSymbols

o  allowLiteralNameSpaceSymbols: aBoolean
attn: possibly sent via perform (Parser >> parsePragma)

o  allowLocalVariableDeclarationWithInitializerExpression

o  allowLocalVariableDeclarationWithInitializerExpression: aBoolean
attn: possibly sent via perform (Parser >> parsePragma)

o  allowNationalCharactersInIdentifier

o  allowNationalCharactersInIdentifier: aBoolean
attn: possibly sent via perform (Parser >> parsePragma)

o  allowOldStyleAssignment
return true, if underscore-assignment (pre ST-80v4 syntax) are to be allowed

o  allowOldStyleAssignment: aBoolean
return true, if underscore-assignment (pre ST-80v4 syntax) are to be allowed

o  allowParagraphInIdentifier
return true, if §-characters are allowed in identifiers (treated as letter)

o  allowParagraphInIdentifier: aBoolean
attn: possibly sent via perform (Parser >> parsePragma)

o  allowPeriodAsNameSpaceSeparator
experimental syntax: foo.bar

o  allowPeriodAsNameSpaceSeparator: aBoolean
experimental syntax: foo.bar

o  allowPeriodInSymbol

o  allowPeriodInSymbol: aBoolean
attn: possibly sent via perform (Parser >> parsePragma)

o  allowQualifiedNames
return true, if '#{..}' and 'namespace.varName' qualified names are allowed

o  allowQualifiedNames: aBoolean
attn: possibly sent via perform (Parser >> parsePragma)

o  allowRStrings
rstrings have the syntax:
r'...'
which generates a regex

o  allowRStrings: aBoolean
rstrings have the syntax:
r'...'
which generates a regex

o  allowReservedWordsAsSelectors
if true, 'self', 'super', 'thisContext', 'nil', 'true' and 'false' are allowed
as unary message selectors.

o  allowReservedWordsAsSelectors: aBoolean
enable/disable, if 'self', 'super', 'thisContext', 'nil', 'true' and 'false' are to be allowed
as unary message selectors.

o  allowSTVExtensions
return true, if support for ST/V extensions is enabled.

o  allowSTVExtensions: aBoolean
if support for ST/V extensions is enabled.

o  allowSTVPrimitives
return true, if support for ST/V primitives is enabled.

o  allowSTVPrimitives: aBoolean
if support for ST/V primitives is enabled.

o  allowSTXDelimiterComments
are ST/X token-delimited comments allowed?
(see comment on class side)

o  allowSTXDelimiterComments: aBoolean
are ST/X token-delimited comments allowed? (default is true)
(see comment on class side)

usage example(s):

     ParserFlags allowSTXDelimiterComments:false
     ParserFlags allowSTXDelimiterComments:true

o  allowSTXEOLComments
are ST/X end-of-line comments allowed?

o  allowSTXEOLComments: aBoolean
are ST/X end-of-line comments allowed? (default is true)

usage example(s):

     ParserFlags allowSTXEOLComments:false
     ParserFlags allowSTXEOLComments:true

o  allowSTXExtendedArrayLiterals
are scheme-style typed literal arrays allowed?

o  allowSTXExtendedArrayLiterals: aBoolean
are scheme-style typed literal arrays allowed?

o  allowSTXFunctions

o  allowSignedByteArrayElements

o  allowSignedByteArrayElements: aBoolean
attn: possibly sent via perform (Parser >> parsePragma)

o  allowSqueakExtensions
return true, if support for squeak extensions
computed arrays { .., }
c/java style arguments in message sends rec foo(arg1, ... argN)
is enabled.

o  allowSqueakExtensions: aBoolean
this allows turning on/off support for squeak extensions:
computed arrays { .., }
c/java style arguments in message sends rec foo(arg1, ... argN)
attn: possibly sent via perform (Parser >> parsePragma)

o  allowSqueakPrimitives
return true, if support for squeak primitives is enabled.

o  allowSqueakPrimitives: aBoolean
this allows turning on/off support for squeak primitives

o  allowStringEscapes

o  allowStringEscapes: aBoolean
attn: possibly sent via perform (Parser >> parsePragma)

o  allowSymbolsStartingWithDigit
return true, if a symbol is allowed to start with a digit
i.e. as in #2D.
This seems to be ok in new Squeak/Pharo versions

o  allowSymbolsStartingWithDigit: aBoolean
control if a symbol is allowed to start with a digit
i.e. as in #2D.
This seems to be ok in new Squeak/Pharo versions.
attn: possibly sent via perform (Parser >> parsePragma)

o  allowUnderscoreInIdentifier

o  allowUnderscoreInIdentifier: aBoolean
attn: possibly sent via perform (Parser >> parsePragma)

o  allowUnicodeCharacters

o  allowUnicodeCharacters: aBoolean
attn: possibly sent via perform (Parser >> parsePragma)

o  allowUnicodeStrings

o  allowUnicodeStrings: aBoolean
attn: possibly sent via perform (Parser >> parsePragma)

o  allowVariableReferences

o  allowVariableReferences: aBoolean
attn: possibly sent via perform (Parser >> parsePragma)

o  allowVisualAgeESSymbolLiterals

o  allowVisualAgeESSymbolLiterals: aBoolean
attn: possibly sent via perform (Parser >> parsePragma)

o  allowVisualAgePrimitives
return true, if support for V'Age primitives is enabled.

o  allowVisualAgePrimitives: aBoolean
this allows turning on/off support for V'Age primitives

o  allowVisualWorksMethodAnnotations
return true, if support for V'Works extended primitive syntax for method annotations.

o  allowVisualWorksMethodAnnotations: aBoolean
turn on/off support for V'Works extended primitive syntax for method annotations.

accessing-warning-control
o  warnAboutBadComments

o  warnAboutBadComments: aBoolean

o  warnAboutNonLowercaseLocalVariableNames

o  warnAboutNonLowercaseLocalVariableNames: aBoolean

o  warnAboutPeriodInSymbol

o  warnAboutPeriodInSymbol: aBoolean

o  warnAboutPossibleSTCCompilationProblems

o  warnAboutPossibleSTCCompilationProblems: aBoolean

o  warnAboutPossiblyUnimplementedSelectors

o  warnAboutPossiblyUnimplementedSelectors: aBoolean

o  warnAboutPossiblyUninitializedLocals

o  warnAboutPossiblyUninitializedLocals: aBoolean

o  warnAboutReferenceToPrivateClass
controls generation of warning messages when a private class is referenced

o  warnAboutReferenceToPrivateClass: aBoolean
controls generation of warning messages when a private class is referenced

o  warnAboutShortLocalVariableNames

o  warnAboutShortLocalVariableNames: aBoolean

o  warnAboutUnknownCharacterEscapesInJavaScriptStringConstant

o  warnAboutUnknownCharacterEscapesInJavaScriptStringConstant: aBoolean

o  warnAboutVariableNameConventions

o  warnAboutVariableNameConventions: aBoolean

o  warnAboutWrongVariableNames

o  warnAboutWrongVariableNames: aBoolean

o  warnAssignmentToBlockArgument

o  warnAssignmentToBlockArgument: aBoolean

o  warnAssignmentToMethodArgument

o  warnAssignmentToMethodArgument: aBoolean

o  warnAssignmentToPoolVariable

o  warnAssignmentToPoolVariable: aBoolean

o  warnCommonMistakes

o  warnCommonMistakes: aBoolean

o  warnDollarInIdentifier

o  warnDollarInIdentifier: aBoolean

o  warnHiddenVariables

o  warnHiddenVariables: aBoolean
controls generation of warning messages about hiding variables by locals

o  warnInconsistentReturnValues

o  warnInconsistentReturnValues: aBoolean

o  warnOldStyleAssignment

o  warnOldStyleAssignment: aBoolean

o  warnParagraphInIdentifier

o  warnParagraphInIdentifier: aBoolean

o  warnPlausibilityChecks
controls generation of warning messages about plausibility checks (possible precedence, etc.)

o  warnPlausibilityChecks: aBoolean
controls generation of warning messages about plausibility checks (possible precedence, etc.)

o  warnPossibleIncompatibilities
holds true, if possible incompatibilities (with other ST systems)
are to be warned about

o  warnPossibleIncompatibilities: aBoolean
holds true, if possible incompatibilities (with other ST systems)
are to be warned about

o  warnST80Directives

o  warnST80Directives: aBoolean

o  warnSTXHereExtensionUsed

o  warnSTXHereExtensionUsed: aBoolean

o  warnSTXNameSpaceUse

o  warnSTXNameSpaceUse: aBoolean

o  warnSTXSpecialComment

o  warnSTXSpecialComment: aBoolean

o  warnUndeclared

o  warnUndeclared: aBoolean

o  warnUnderscoreInIdentifier

o  warnUnderscoreInIdentifier: aBoolean

o  warnUnusedVars

o  warnUnusedVars: aBoolean

o  warnings

o  warnings: aBoolean

initialization
o  initialize
each instance is initially setup from the classes global defaults.
(but can be changed as required for an individual compilation run

usage example(s):

     ParserFlags initialize.
     self new inspect.



ST/X 7.2.0.0; WebServer 1.670 at bd0aa1f87cdd.unknown:8081; Wed, 10 Aug 2022 11:59:46 GMT