eXept Software AG Logo

Smalltalk/X Webserver

Documentation of class 'RBProgramNode':

Home

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

Class: RBProgramNode


Inheritance:

   Object
   |
   +--RBProgramNode
      |
      +--RBMethodNode
      |
      +--RBPragmaNode
      |
      +--RBSequenceNode
      |
      +--RBStatementNode

Package:
stx:goodies/refactoryBrowser/parser
Category:
Refactory-AST-Nodes
Version:
rev: 1.104 date: 2018/05/24 19:01:08
user: cg
file: RBProgramNode.st directory: goodies/refactoryBrowser/parser
module: stx stc-classLibrary: parser

Description:


BRProgramNode is an abstract class that represents an abstract syntax tree node in a Smalltalk program.

Subclasses must implement the following messages:
        accessing
                start
                stop
        visitor
                acceptVisitor:

The #start and #stop methods are used to find the source that corresponds to this node. "source copyFrom: self start to: self stop" should return the source for this node.

The #acceptVisitor: method is used by BRProgramNodeVisitors (the visitor pattern). This will also require updating all the BRProgramNodeVisitors so that they know of the new node.

Subclasses might also want to redefine match:inContext: and copyInContext: to do parse tree searching and replacing.

Subclasses that contain other nodes should override equalTo:withMapping: to compare nodes while ignoring renaming temporary variables, and children that returns a collection of our children nodes.

Instance Variables:
        comments        <Collection of: Interval>       the intervals in the source that have comments for this node
        parent  <BRProgramNode> the node we're contained in


Class protocol:

accessing
o  formatterClass

o  formatterClass: aClass

o  optimizedSelectors

initialization
o  initialize


Instance protocol:

accessing
o  asReturn
Change the current node to a return node.

o  blockScope

o  children

o  comments

o  comments: aCollection

o  commentsAfter

o  commentsAfter: aCollectionOfComments

o  commentsBefore

o  commentsBefore: aCollectionOfComments
'oops - loosing comments before'.

o  endPosition

o  formattedCode

o  formatterClass

o  lineNumber
lineNumber isNil ifTrue:[

o  lineNumber: anInteger
Modified (format): / 06-03-2012 / 11:13:19 / cg

o  methodScope

o  newSource

o  originalCode

o  originalFormattedCode
same as formattedCode, but does not rewrite '_' to ':='

o  parent

o  parent: anObject

o  parents

o  precedence

o  removeCommentsAfter
occasionally someone wants to move comments from one node to another;
this is a helper to clear the comments in the old node.
(see senders of why this is done)

o  source

o  sourceInterval

o  start

o  startPosition

o  startWithoutParentheses

o  stop

o  stopPosition

o  topNode

o  typeInfo
this is a hook for the type inferer;
it may attach additional info to a node with this

o  typeInfo: someArbitraryThingy
this is a hook for the type inferer;
it may attach additional info to a node with this

comparing
o  equalTo: aNode exceptForVariables: variableNameCollection

o  equalTo: aNode withMapping: aDictionary
return true, if I am equal to another node, with a given variable name mapping.
Side effect: update the mapping dictionary as required to reflect a matching mapping (if possible)

o  equalTo: aNode withSelectorMapping: aDictionary
return true, if I am equal to another node, with a given selector name mapping.
Side effect: update the mapping dictionary as required to reflect a matching mapping (if possible)

o  semanticallyEqualTo: aNode withMapping: aDictionary
return true, if I am semantically equal to another node, with a given variable name mapping.
Semantical equalTo: is defined slightly less strict, than equalTo:.
Both check the parsetree, ignoring formatting and comments.
However, in some situations, semanticallyEqualTo: detects the same intention,
(which is mostly heuristic and builtin knowledge).
For example:
foo isNil ifTrue:e1 ifFalse:e2
is semantcallyEqualTo:
foo notNil ifTrue:e2 ifFalse:e1
and also to:
foo isNil ifFalse:e2 ifTrue:e1
The fallback implemented here is to ask for the regular equality.
Side effect: update the mapping dictionary as required to reflect a matching mapping (if possible)

copying
o  copy
This is redefined for IBM Smalltalk which doesn't have postCopy.

o  copyCommentsFrom: aNode
Add all comments from aNode to us. If we already have the comment, then don't add it.

o  postCopy

enumeration
o  allAssignmentNodesDo: aBlock

o  allBlockNodesDo: aBlock

o  allLiteralNodesDo: aBlock

o  allMessageNodesDo: aBlock

o  allNonPatternMessageNodesDo: aBlock

o  allReturnNodesDo: aBlock

o  collect: aBlock
Hacked to fit collection protocols

o  detectParentForWhich: aBlock

o  do: aBlock
Hacked to fit collection protocols

o  size
Hacked to fit collection protocols

o  variableNodesDo: aBlock
evaluate a Block for all variable nodes

iteration
o  nodesDo: aBlock

matching
o  copyInContext: aDictionary

o  copyList: matchNodes inContext: aDictionary

o  match: aNode inContext: aDictionary

o  matchList: matchNodes against: programNodes inContext: aDictionary

o  matchList: matchNodes index: matchIndex against: programNodes index: programIndex inContext: aDictionary

meta variable-accessing
o  cascadeListCharacter

o  ignoreInMatchCharacter

o  listCharacter

o  literalCharacter

o  recurseIntoCharacter

o  statementCharacter

printing
o  printOn: aStream

querying
o  allAssignmentNodes

o  allMessageNodes

o  assigns: aVariableName

o  bestNodeFor: anInterval

o  containedBy: anInterval

o  containsReturn

o  defines: aName

o  directlyUses: aNode

o  evaluatedFirst: aNode

o  firstLineNumber

o  hasAssignmentNodes

o  hasBlockNodes

o  hasFalseValue

o  hasReturnNodes

o  hasTrueValue

o  intersectsInterval: anInterval
^(anInterval first between:myStart and:myStop)

o  isChildOf: anotherNode

o  isDirectlyUsed
This node is directly used as an argument, receiver, or part of an assignment.

o  isEvaluatedFirst
Return true if we are the first thing evaluated in this statement.

o  isInsidePatternNode

o  isLast: aNode

o  isLoop

o  isReferringToAnExceptionInContext: aSearchDictionary
this is not comletely true;
for example, I could be a message such as: expr1 , expr2
where either expr refers to an Exception

o  lastIsLoop

o  lastIsReturn

o  lastLineNumber
lineNumber isNil ifTrue:[self halt:'should always be non-nil'].

o  reads: aVariableName

o  references: aVariableName
(comment from inherited method)
return true if the receiver refers to the argument, anObject.
- for debugging only

o  selfMessages
warning: returns a string collection because we avoid creating symbols when parsing

o  sentMessages

o  statementNode
Return your topmost node that is contained by a sequence node.

o  superMessages
warning: returns a string collection because we avoid creating symbols when parsing

o  uses: aNode

replacing
o  removeDeadCode

o  replaceNode: aNode withNode: anotherNode

o  replaceWith: aNode

searching
o  whichNodeIntersects: anInterval
I intersect

o  whichNodeIsContainedBy: anInterval

o  whoDefines: aName

special queries
o  addAllCommentsTo: aCollection

o  addReferencedVariablesTo: aCollection

o  addUsedLiteralsTo: aCollection
adds the values of all literals to aCollection

o  addUsedSymbolsTo: aCollection

o  allArgumentVariables

o  allArgumentVariablesInto: aCollection

o  allComments

o  allDefinedVariables

o  allTemporaryVariables

o  allVariablesOnScope

o  blockVariables

o  referencedVariables

o  temporaryVariables

o  usedLiterals
returns a set of the literal values (i.e. not the nodes)

o  usedSymbols
returns a set of the symbols used (i.e. not the nodes)

stx:libtool support
o  highlightInCodeView: aCodeView

o  leftClickMenuInCodeView: aCodeView

o  middleClickMenuInCodeView: aCodeView

o  rightClickMenuInCodeView: aCodeView

testing
o  isAssignment

o  isBlock

o  isCascade

o  isClassVariableInContext: aSearchDictionary

o  isGlobal
Return true if the variable node is for
a global variable, false otherwise

o  isImmediate

o  isInstanceVariable

o  isKeywordMessage

o  isLiteral

o  isLiteralArray

o  isLiteralByteArray

o  isLiteralCharacter

o  isLiteralFloat

o  isLiteralInteger

o  isLiteralNil

o  isLiteralNode

o  isLiteralNumber

o  isLiteralString

o  isLiteralSymbol

o  isMessage

o  isMessageWithSelector: aStringOrSymbol

o  isMethod

o  isPragma

o  isReturn

o  isSTXPrimitiveCCode

o  isSelf
true if I am the self-variable node

o  isSequence

o  isSqueakArray

o  isSuper

o  isTemporary
Return true if the variable node is for
a temporary variable, false otherwise

o  isUsed
Answer true if this node could be used as part of another expression. For example, you could use the
result of this node as a receiver of a message, an argument, the right part of an assignment, or the
return value of a block. This differs from isDirectlyUsed in that it is conservative since it also includes
return values of blocks.

o  isValue

o  isVariable

o  isVariableNotInLeftHandSideOfAssignment
Returns true iff receiver is variable node but not
in left-hand side of assignment

testing-matching
o  canMatchMethod: aCompiledMethod
the original code below iterates over the literals for each tested;

o  isList

o  isPatternNode

o  recurseInto

visitor
o  acceptCommentsAfterVisitor: aVisitor

o  acceptCommentsBeforeVisitor: aVisitor

o  acceptVisitor: aProgramNodeVisitor


Private classes:

    AuxInfo


ST/X 7.1.0.0; WebServer 1.663 at exept.de:8081; Sat, 17 Nov 2018 08:39:21 GMT