comma::ParseClient Class Reference

#include <ParseClient.h>

Inheritance diagram for comma::ParseClient:
Inheritance graph
[legend]

List of all members.

Public Member Functions

Node getNullNode ()
Node getInvalidNode ()
virtual void deleteNode (Node &node)=0
virtual void acceptFormalDomain (IdentifierInfo *name, Location loc, Node sig)=0
virtual void acceptSupersignature (Node typeNode)=0
 Called for each super signature defined in a signature profile.
virtual void beginAddExpression ()=0
virtual void endAddExpression ()=0
 Completes an add expression.
virtual void acceptCarrier (IdentifierInfo *name, Location loc, Node typeNode)=0
 Invoked when the parser consumes a carrier declaration.
virtual Node acceptNullStmt (Location loc)=0
 Called to notify the client of a null statement at the given position.
virtual bool acceptStmt (Node context, Node stmt)=0
virtual bool acceptObjectDeclaration (Location loc, IdentifierInfo *name, Node type, Node initializer)=0
virtual bool acceptRenamedObjectDeclaration (Location loc, IdentifierInfo *name, Node type, Node target)=0
virtual Node acceptPercent (Location loc)=0
virtual Node acceptProcedureCall (Node name)=0
virtual Node acceptInj (Location loc, Node expr)=0
virtual Node acceptPrj (Location loc, Node expr)=0
virtual Node acceptIntegerLiteral (llvm::APInt &value, Location loc)=0
virtual Node acceptStringLiteral (const char *string, unsigned len, Location loc)=0
virtual Node acceptNullExpr (Location loc)=0
virtual Node acceptAllocatorExpr (Node operand, Location loc)=0
virtual Node acceptQualifiedExpr (Node qualifier, Node operand)=0
virtual Node acceptDereference (Node prefix, Location loc)=0
virtual bool acceptImportDeclaration (Node importedType)=0
 Submits an import from the given type node.
virtual Node acceptIfStmt (Location loc, Node condition, NodeVector &consequents)=0
virtual Node acceptElseStmt (Location loc, Node ifNode, NodeVector &alternates)=0
virtual Node acceptElsifStmt (Location loc, Node ifNode, Node condition, NodeVector &consequents)=0
virtual Node acceptEmptyReturnStmt (Location loc)=0
virtual Node acceptReturnStmt (Location loc, Node retNode)=0
virtual Node acceptAssignmentStmt (Node target, Node value)=0
virtual Node acceptWhileStmt (Location loc, Node condition, NodeVector &stmtNodes)=0
 Called to inform the client of a while statement.
virtual Node acceptLoopStmt (Location loc, NodeVector &stmtNodes)=0
 Called to inform the client of a loop statement.
virtual Node acceptRaiseStmt (Location loc, Node exception, Node message)=0
virtual Node acceptPragmaStmt (IdentifierInfo *name, Location loc, NodeVector &pragmaArgs)=0
 Called when a pragma is encountered within a sequence of statements.
virtual void acceptPragmaImport (Location pragmaLoc, IdentifierInfo *convention, Location conventionLoc, IdentifierInfo *enity, Location entityLoc, Node externalNameNode)=0
virtual void acceptIntegerTypeDecl (IdentifierInfo *name, Location loc, Node low, Node high)=0
virtual void acceptRangedSubtypeDecl (IdentifierInfo *name, Location loc, Node subtype, Node low, Node high)=0
virtual void acceptSubtypeDecl (IdentifierInfo *name, Location loc, Node subtype)=0
virtual void acceptIncompleteTypeDecl (IdentifierInfo *name, Location loc)=0
virtual void acceptAccessTypeDecl (IdentifierInfo *name, Location loc, Node subtype)=0
 Called to notify the client of an access type declaration.
virtual void acceptArrayDecl (IdentifierInfo *name, Location loc, NodeVector indices, Node component)=0
 Communicates an array type declaration.
Initial Callbacks.

When a top-level capsule is about to be parsed, beginCapsule is invoked to notify the client of the processing to come. This is the first callback the parser ever invokes on its client. Once the capsule has been parsed (successfully or not), endCapsule is called.



virtual void beginCapsule ()=0
virtual void endCapsule ()=0
Generic Formal Delimiters.

Processing of a generic formal part begins with a call to beginGenericFormals and completes with a call to endGenericFormals. These calls delimit the scope of a generic formal part to the client.



virtual void beginGenericFormals ()=0
virtual void endGenericFormals ()=0
Capsule Callbacks.

Once the generic formal part has been processed (if present at all), one following callbacks is invoked to inform the client of the type and name of the upcomming capsule. The context established by these callbacks is terminated when endCapsule is called.



virtual void beginDomainDecl (IdentifierInfo *name, Location loc)=0
virtual void beginSignatureDecl (IdentifierInfo *name, Location loc)=0
Signature Profile Delimiters

When the signature profile of a top-level capsule or generic formal domain is about to be processed, beginSignatureProfile is called. Once the processing of the profile is finished (regarless of whether the parse was successful or not) endSignatureProfile is called.



virtual void beginSignatureProfile ()=0
virtual void endSignatureProfile ()=0
Subroutine Declaration Callbacks.

When a subroutine declaration is about to be parsed, either beginFunctionDeclaration or beginProcedureDeclaration is invoked to inform the client of the kind and name of the upcomming subroutine. Once the declaration has been processed, the context is terminated with a call to endSubroutineDeclaration.



virtual void beginFunctionDeclaration (IdentifierInfo *name, Location loc)=0
virtual void beginProcedureDeclaration (IdentifierInfo *name, Location loc)=0
virtual void acceptFunctionReturnType (Node typeNode)=0
virtual void acceptSubroutineParameter (IdentifierInfo *formal, Location loc, Node typeNode, PM::ParameterMode mode)=0
virtual Node endSubroutineDeclaration (bool definitionFollows)=0
Subroutine Definition Callbacks.



virtual Node beginSubroutineDefinition (Node declarationNode)=0
virtual void endSubroutineBody (Node context)=0
virtual void endSubroutineDefinition ()=0
Name Callbacks

Callbacks concerned with the specification of Comma names.



virtual Node acceptDirectName (IdentifierInfo *name, Location loc, bool forStatement)=0
virtual Node acceptCharacterLiteral (IdentifierInfo *lit, Location loc)=0
virtual Node acceptSelectedComponent (Node prefix, IdentifierInfo *name, Location loc, bool forStatement)=0
virtual Node acceptParameterAssociation (IdentifierInfo *key, Location loc, Node rhs)=0
virtual Node acceptApplication (Node prefix, NodeVector &argumentNodes)=0
virtual Node acceptAttribute (Node prefix, IdentifierInfo *name, Location loc)=0
virtual Node finishName (Node name)=0
Aggregate Callbacks.

Processing of an aggregate expresion is bracketed by calls to beginAggregate and endAggregate.

First, each positional component of the aggregate is processed and the client is notified with a call to acceptPositionalAggregateComponent.

Next, every keyed component is processed. This is a two stage affair. For each key one of the acceptAggregateKey methods is invoked. Finally, acceptKeyedAggregateComponent is called with a NodeVector containing each key along with the associated expression.

Finally, if the aggregate contains an others clause acceptAggregateOthers is called.



virtual void beginAggregate (Location loc)=0
virtual void acceptPositionalAggregateComponent (Node component)=0
 Provides a Node describing a positional component of the aggregate.
virtual Node acceptAggregateKey (Node lower, Node upper)=0
 Called to indicate an aggregate key in the form of a range.
virtual Node acceptAggregateKey (Node key)=0
virtual Node acceptAggregateKey (IdentifierInfo *name, Location loc)=0
 Called to indicate an aggregate key consisting of a single identifier.
virtual void acceptKeyedAggregateComponent (NodeVector &keys, Node expr, Location loc)=0
virtual void acceptAggregateOthers (Location loc, Node component)=0
virtual Node endAggregate ()=0
For Statement Callbacks.

A for statement is introduced to the client with a call to beginForStmt(). The parser processes each statement in the loop body and terminates the construct with a call to endForStmt().



virtual Node beginForStmt (Location loc, IdentifierInfo *iterName, Location iterLoc, Node control, bool isReversed)=0
virtual Node endForStmt (Node forNode, NodeVector &bodyNodes)=0
Discrete Subtype Definition Callbacks.

The following methods inform the client of a discrete subtype definition. These methods are invoked when parsing array index definitions and the control specification of for statements.



virtual Node acceptDSTDefinition (Node name, Node lower, Node upper)=0
virtual Node acceptDSTDefinition (Node nameOrAttribute, bool isUnconstrained)=0
virtual Node acceptDSTDefinition (Node lower, Node upper)=0
Block Callbacks.

Blocks are introduced with a call to beginBlockStmt and terminated with a call to endBlockStmt. Each item in the blocks declarative region is processed via one of the declaration callbacks. Each statement associated with the block is registerd via a call to acceptStmt with the context being the node returned by the initial call to beginBlockStmt.



virtual Node beginBlockStmt (Location loc, IdentifierInfo *label=0)=0
 Called when a block statement is about to be parsed.
virtual void endBlockStmt (Node block)=0
Exception Handler Callbacks.



virtual Node beginHandlerStmt (Location loc, NodeVector &choices)=0
virtual void endHandlerStmt (Node context, Node handler)=0
Enumeration Callbacks.

Enumerations are processed by first establishing a context with a call to beginEnumeration. For each defining enumeration literal, either acceptEnumerationIdentifier or acceptEnumerationCharacter is called. Once all elements of the type have been processed, endEnumeration is called.



virtual void beginEnumeration (IdentifierInfo *name, Location loc)=0
virtual void acceptEnumerationIdentifier (IdentifierInfo *name, Location loc)=0
virtual void acceptEnumerationCharacter (IdentifierInfo *name, Location loc)=0
virtual void endEnumeration ()=0
Record Type Declaration Callbacks.

Record type declarations are braketed between calls to beginRecord and endRecord. For each component of the record type a call to acceptRecordComponent is called.



virtual void beginRecord (IdentifierInfo *name, Location loc)=0
virtual void acceptRecordComponent (IdentifierInfo *name, Location loc, Node type)=0
virtual void endRecord ()=0
 Completes the definition of a record type.

Protected Member Functions

Node getNode (void *ptr)
 Allow sub-classes to construct arbitrary nodes.
Node getReleasedNode (void *ptr)

Detailed Description

Definition at line 172 of file ParseClient.h.


Member Function Documentation

virtual void comma::ParseClient::acceptAccessTypeDecl ( IdentifierInfo name,
Location  loc,
Node  subtype 
) [pure virtual]

Called to notify the client of an access type declaration.

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::acceptAggregateKey ( IdentifierInfo name,
Location  loc 
) [pure virtual]

Called to indicate an aggregate key consisting of a single identifier.

This callback is provided to support selectors of a record aggregate. Since Comma aggregates cannot be resolved without a type context it is not reasonable to expect a ParseClient implementation to divine the meaning of aggregate keys. This callback allows a client to defer the processing of aggregate keys which may resolve to a record selector or to a direct name until enough context is established.

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::acceptAggregateKey ( Node  key  )  [pure virtual]

Called to indicate an aggregate key consisting of an expression or subtype indication.

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::acceptAggregateKey ( Node  lower,
Node  upper 
) [pure virtual]

Called to indicate an aggregate key in the form of a range.

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::acceptAggregateOthers ( Location  loc,
Node  component 
) [pure virtual]

Indicates an "others" component. If this callback is invoked, it is always the last component processed by the parser.

Parameters:
loc Location of the "others" reserved word.
component An expression denoting the default value for this aggregate, or a null node if others => <> was parsed.

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::acceptAllocatorExpr ( Node  operand,
Location  loc 
) [pure virtual]

Incoked whten the parser encounters an allocator expression.

Parameters:
operand The argument to the allocator. This is either a name or result of acceptQualifiedExpr.
loc Location of the "new" reserved word.

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::acceptApplication ( Node  prefix,
NodeVector argumentNodes 
) [pure virtual]

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::acceptArrayDecl ( IdentifierInfo name,
Location  loc,
NodeVector  indices,
Node  component 
) [pure virtual]

Communicates an array type declaration.

Parameters:
name The name of this array type declaration.
loc the location of name.
indices A set of nodes defining the index specification for this array, each being the result of a call to acceptDSTDefinition.
component The component type of the array declaration.

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::acceptAssignmentStmt ( Node  target,
Node  value 
) [pure virtual]

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::acceptAttribute ( Node  prefix,
IdentifierInfo name,
Location  loc 
) [pure virtual]

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::acceptCarrier ( IdentifierInfo name,
Location  loc,
Node  typeNode 
) [pure virtual]

Invoked when the parser consumes a carrier declaration.

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::acceptCharacterLiteral ( IdentifierInfo lit,
Location  loc 
) [pure virtual]

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::acceptDereference ( Node  prefix,
Location  loc 
) [pure virtual]

Notifies the client of an explicit dereference expression.

Parameters:
prefix The name to be dereferenced.
loc Location of the reserved word all.

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::acceptDirectName ( IdentifierInfo name,
Location  loc,
bool  forStatement 
) [pure virtual]

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::acceptDSTDefinition ( Node  lower,
Node  upper 
) [pure virtual]

Indicates a discrete subtype definition that was sepcified using only a range.

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::acceptDSTDefinition ( Node  nameOrAttribute,
bool  isUnconstrained 
) [pure virtual]

Indicates a discrete subtype definition which was specified using a name which may include a range attribute. If isUnconstrained is true, then the given node was followed by the "range <>" syntax, and the parser is in the midst of processing an array type definition.

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::acceptDSTDefinition ( Node  name,
Node  lower,
Node  upper 
) [pure virtual]

Indicates a discrete subtype definition which was accompanied by a range constraint.

Parameters:
name The subtype mark of this definition.
lower The lower bound of the range constraint.
upper The upper bound of the range constraint.

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::acceptElseStmt ( Location  loc,
Node  ifNode,
NodeVector alternates 
) [pure virtual]

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::acceptElsifStmt ( Location  loc,
Node  ifNode,
Node  condition,
NodeVector consequents 
) [pure virtual]

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::acceptEmptyReturnStmt ( Location  loc  )  [pure virtual]

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::acceptEnumerationCharacter ( IdentifierInfo name,
Location  loc 
) [pure virtual]

Called to introduce an enumeration component which was defined using character syntax.

Parameters:
name The name of the character literal defining this component. This is always the full name of the literal. For example, the character literal for X is named using the string "'X'" (note that the quotes are included).
loc The location of the defining character literal.

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::acceptEnumerationIdentifier ( IdentifierInfo name,
Location  loc 
) [pure virtual]

Called to introduce an enumeration component which was defined using identifier syntax.

Parameters:
name The defining identifier for this component.
loc The location of the defining identifier.

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::acceptFormalDomain ( IdentifierInfo name,
Location  loc,
Node  sig 
) [pure virtual]

Called to notify the client of a generic formal domain parameter.

Parameters:
name The defining identifier of the domain.
loc Location of the defining identifier.
sig If the formal domain was specified as satisfying a particular signature, sig is a valid node as returned by a call to parseName(). Otherwise sig is a null node.

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::acceptFunctionReturnType ( Node  typeNode  )  [pure virtual]

When parsing a function declaration, this callback is invoked to notify the client of the declarations return type.

If the function declaration was missing a return type, or the node returned by the client representing the type is invalid, this callback is passed a null node as argument. Note that the parser posts a diagnostic for the case of a missing return.

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::acceptIfStmt ( Location  loc,
Node  condition,
NodeVector consequents 
) [pure virtual]

Implemented in comma::TypeCheck.

virtual bool comma::ParseClient::acceptImportDeclaration ( Node  importedType  )  [pure virtual]

Submits an import from the given type node.

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::acceptIncompleteTypeDecl ( IdentifierInfo name,
Location  loc 
) [pure virtual]

Called to notify the client of an incomplete type declaration.

This callback is invoked when processing type declarations of the form type Foo;<>.

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::acceptInj ( Location  loc,
Node  expr 
) [pure virtual]

Called for "inj" expressions. loc is the location of the inj token and expr is its argument.

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::acceptIntegerLiteral ( llvm::APInt &  value,
Location  loc 
) [pure virtual]

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::acceptIntegerTypeDecl ( IdentifierInfo name,
Location  loc,
Node  low,
Node  high 
) [pure virtual]

Called to process integer type declarations.

For example, given a definition of the form type T is range X..Y;, this callback is invoked with name set to the identifier T, loc set to the location of name, low set to the expression X, and high set to the expression Y.

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::acceptKeyedAggregateComponent ( NodeVector keys,
Node  expr,
Location  loc 
) [pure virtual]

Provides a vector of keys and associated expression for a keyed aggregate component.

Parameters:
keys A vector of valid nodes as returned by acceptAggregateKey.
expr Expression denoting the value associated with the given keys, or a null node if a diamond was parsed.
loc Location of the given expression (for use when expr is null).
Note:
The parser will always call this method if it is able to parse the associated expression. This means that keys may be empty if none of the keys parsed correctly or the client returned an invalid node for them all.

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::acceptLoopStmt ( Location  loc,
NodeVector stmtNodes 
) [pure virtual]

Called to inform the client of a loop statement.

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::acceptNullExpr ( Location  loc  )  [pure virtual]

Invoked when the parser encounters the "null" reserved word in an expression context.

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::acceptNullStmt ( Location  loc  )  [pure virtual]

Called to notify the client of a null statement at the given position.

Implemented in comma::TypeCheck.

virtual bool comma::ParseClient::acceptObjectDeclaration ( Location  loc,
IdentifierInfo name,
Node  type,
Node  initializer 
) [pure virtual]

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::acceptParameterAssociation ( IdentifierInfo key,
Location  loc,
Node  rhs 
) [pure virtual]

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::acceptPercent ( Location  loc  )  [pure virtual]

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::acceptPositionalAggregateComponent ( Node  component  )  [pure virtual]

Provides a Node describing a positional component of the aggregate.

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::acceptPragmaImport ( Location  pragmaLoc,
IdentifierInfo convention,
Location  conventionLoc,
IdentifierInfo enity,
Location  entityLoc,
Node  externalNameNode 
) [pure virtual]

Called when a pragma Import is encountered. These pragmas can occur when processing a list of declarative items.

Parameters:
pragmaLoc The location of the Import identifier.
convention An identifier naming the convention to be used. Note that the parser does not know what identifiers name valid conventions.
conventionLoc The location of the convention identifier.
entity The identifier naming the entity to import.
entityLoc The location of the entity identifier.
externalNameNode An arbitrary expression node.

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::acceptPragmaStmt ( IdentifierInfo name,
Location  loc,
NodeVector pragmaArgs 
) [pure virtual]

Called when a pragma is encountered within a sequence of statements.

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::acceptPrj ( Location  loc,
Node  expr 
) [pure virtual]

Called for "prj" expressions. loc is the location of the prj token and expr is its argument.

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::acceptProcedureCall ( Node  name  )  [pure virtual]

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::acceptQualifiedExpr ( Node  qualifier,
Node  operand 
) [pure virtual]

Invoked when the parser encounters a qualified expression.

Parameters:
qualifier A node corresponding to the qualified name.
operand The expression to qualify.

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::acceptRaiseStmt ( Location  loc,
Node  exception,
Node  message 
) [pure virtual]

Called to inform the client of a raise statement.

Parameters:
loc Location of the `raise' reserved word.
exception Node representing the exception to be thrown (as obtained thru the name callbacks).
message Contains the expression node to be associated with the `raise', or a null-node if there was no expression.

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::acceptRangedSubtypeDecl ( IdentifierInfo name,
Location  loc,
Node  subtype,
Node  low,
Node  high 
) [pure virtual]

Called to process a range constrained discrete subtype declaration.

For example, given a declaration of the form subtype S is T range X..Y;, this callback is invoked with name set to the identifier S, loc set to the location of name, and subtype set to the subtype indication T, and the last two arguments (low and high) represent the lower and upper bounds of the range constraint.

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::acceptRecordComponent ( IdentifierInfo name,
Location  loc,
Node  type 
) [pure virtual]

Called to notify the client of a record component.

Parameters:
name The defining identifier for this record component.
loc The location of the components defining identifier.
type A node representing the type of this identifier.

Implemented in comma::TypeCheck.

virtual bool comma::ParseClient::acceptRenamedObjectDeclaration ( Location  loc,
IdentifierInfo name,
Node  type,
Node  target 
) [pure virtual]

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::acceptReturnStmt ( Location  loc,
Node  retNode 
) [pure virtual]

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::acceptSelectedComponent ( Node  prefix,
IdentifierInfo name,
Location  loc,
bool  forStatement 
) [pure virtual]

Implemented in comma::TypeCheck.

virtual bool comma::ParseClient::acceptStmt ( Node  context,
Node  stmt 
) [pure virtual]

Called to notify the client that a statement has been completely parsed.

Parameters:
context The result of a call to beginBlockStmt or beginSubroutineDefinition, indicating in which context stmt appeared in.
stmt The actual Node representing the statement (as returned from accpetIfStmt, acceptAssignmentStmt, etc).

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::acceptStringLiteral ( const char *  string,
unsigned  len,
Location  loc 
) [pure virtual]

Invoked when the parser encounters a string literal.

Parameters:
string A pointer to the first quotation character of the string literal. The string is not necessarily null terminated, and is owned by the parser. Clients should copy the contents of the string if needed.
len The number of characters in the string.
loc The location of the first quotation character.

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::acceptSubroutineParameter ( IdentifierInfo formal,
Location  loc,
Node  typeNode,
PM::ParameterMode  mode 
) [pure virtual]

For each subroutine parameter, acceptSubroutineParameter is called providing:

Parameters:
formal The name of the formal parameter.
loc The location of the formal parameter name.
typeNode A node describing the type of the parameter (the result of a call to acceptTypeName or acceptTypeApplication, for example).
mode The parameter mode, wher PM::MODE_DEFAULT is supplied if an explicit mode was not parsed.

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::acceptSubtypeDecl ( IdentifierInfo name,
Location  loc,
Node  subtype 
) [pure virtual]

Called to process an unconstrained subtype declaration.

For example, given a declaration of the form subtype S is T;, this callback is invoked with name set to the identifier S, loc set to the location of name, and subtype set to the subtype indication T.

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::acceptSupersignature ( Node  typeNode  )  [pure virtual]

Called for each super signature defined in a signature profile.

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::acceptWhileStmt ( Location  loc,
Node  condition,
NodeVector stmtNodes 
) [pure virtual]

Called to inform the client of a while statement.

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::beginAddExpression (  )  [pure virtual]

Called at the begining of an add expression. The client accepts components of an add expression after this call until endAddExpression is called.

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::beginAggregate ( Location  loc  )  [pure virtual]

The start of an aggregate expression is communicated to the client with a call to beginAggregate(). For each component of the aggregate acceptAggregateComponent() is called. The end of the aggregate expression is voiced with a call to endAggregate(). Signals that an aggregate expression is about to be processed.

Parameters:
loc Location of opening paren starting the aggregate.

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::beginBlockStmt ( Location  loc,
IdentifierInfo label = 0 
) [pure virtual]

Called when a block statement is about to be parsed.

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::beginCapsule (  )  [pure virtual]

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::beginDomainDecl ( IdentifierInfo name,
Location  loc 
) [pure virtual]

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::beginEnumeration ( IdentifierInfo name,
Location  loc 
) [pure virtual]

Establishes a context beginning an enumeration type declaration.

Parameters:
name The name of this enumeration type declaration.
loc The location of the enumerations name.

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::beginForStmt ( Location  loc,
IdentifierInfo iterName,
Location  iterLoc,
Node  control,
bool  isReversed 
) [pure virtual]

Begins a for statement.

Parameters:
loc Location of the for reserved word.
iterName Defining identifier for the loop parameter.
iterLoc Location of iterName.
control A node representing the subtype definition, range, or range attribute controlling this loop. This node is obtained by a call to acceptDSTDefinition.
isReversed Set to true when the reverse reserved word was present in the loop specification.
Returns:
A node representing the for loop being processed. The returned value is supplied to the corresponding endForStmt() call.

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::beginFunctionDeclaration ( IdentifierInfo name,
Location  loc 
) [pure virtual]

When parsing a function declaration, this callback is invoked to notify the client of the declarations return type.

If the function declaration was missing a return type, or the node returned by the client representing the type is invalid, this callback is passed a null node as argument. Note that the parser posts a diagnostic for the case of a missing return.

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::beginGenericFormals (  )  [pure virtual]

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::beginHandlerStmt ( Location  loc,
NodeVector choices 
) [pure virtual]

Begins an exception handler.

Parameters:
loc Location of the when reserved word.
choices Set of valid nodes as procudueced by the name callbacks representing the set of exceptions this handler covers.
Returns:
A node representing the handler. This node, if valid, is used as the context in a call to acceptStmt for each statement constituting the body of this handler.

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::beginProcedureDeclaration ( IdentifierInfo name,
Location  loc 
) [pure virtual]

When parsing a function declaration, this callback is invoked to notify the client of the declarations return type.

If the function declaration was missing a return type, or the node returned by the client representing the type is invalid, this callback is passed a null node as argument. Note that the parser posts a diagnostic for the case of a missing return.

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::beginRecord ( IdentifierInfo name,
Location  loc 
) [pure virtual]

Begins the definition of a record type.

Parameters:
name The defining identifier for this record.
loc The location of the defining identifier.

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::beginSignatureDecl ( IdentifierInfo name,
Location  loc 
) [pure virtual]

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::beginSignatureProfile (  )  [pure virtual]

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::beginSubroutineDefinition ( Node  declarationNode  )  [pure virtual]

Once a declaration has been parsed, a context for a definition is introduced with a call to beginSubroutineDefinition (assuming the declaration has a definition), passing in the node returned from endSubroutineDeclaration. The returned Node will be used as the first parameter to acceptStmt and endHandlerStmt for each statement and exception handler constituting the definition.

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::deleteNode ( Node node  )  [pure virtual]

Nodes do not know the representation of the data they carry. This method is called by Nodes once their reference counts drop to zero. The implementation need not delete the node as a result of this call -- it might choose to cache it, for instance.

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::endAddExpression (  )  [pure virtual]

Completes an add expression.

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::endAggregate (  )  [pure virtual]

Signals that an aggregate expression has completed.

Returns:
A Node representing the accumulated aggregate expression.

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::endBlockStmt ( Node  block  )  [pure virtual]

Once the last statement of a block has been parsed, this method is called to inform the client that we are leaving the block context established by the last call to beginBlockStmt.

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::endCapsule (  )  [pure virtual]

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::endEnumeration (  )  [pure virtual]

Called when all of the enumeration literals have been processed, thus completing the definition of the enumeration.

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::endForStmt ( Node  forNode,
NodeVector bodyNodes 
) [pure virtual]

Terminates a for statement.

Parameters:
forNode The Node returned by the previous call to beginForStmt().
bodyNodes A vector of nodes corresponding to each statement in the loop body.
Returns:
A node representing the completed for stmt.

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::endGenericFormals (  )  [pure virtual]

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::endHandlerStmt ( Node  context,
Node  handler 
) [pure virtual]

Completes an exception handler.

Parameters:
context A Node which this handler should be associated with. This is the result of a call to beginSubroutineDefinition or beginBlockStmt.
handler The Node returned by a call to beginHandlerStmt.

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::endRecord (  )  [pure virtual]

Completes the definition of a record type.

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::endSignatureProfile (  )  [pure virtual]

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::endSubroutineBody ( Node  context  )  [pure virtual]

Once the sequence of statements constituting the body of the subroutine has been parsed (not counting any exception handlers), this method is invoked to inform the client of the completion of the body.

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::endSubroutineDeclaration ( bool  definitionFollows  )  [pure virtual]

Called to terminate the context of a subroutine declaration.

Parameters:
definitionFollows Set to true if the parser sees a is token following the declaration and thus expects a definition to follow.
Returns:
A node associated with the declaration. Exclusively used by the parser as an argument to beginSubroutineDefinition.

Implemented in comma::TypeCheck.

virtual void comma::ParseClient::endSubroutineDefinition (  )  [pure virtual]

Once endSubroutineBody has been called and any exception handlers have been processed this callback is invoked to signal the completion of the definition.

Implemented in comma::TypeCheck.

virtual Node comma::ParseClient::finishName ( Node  name  )  [pure virtual]

Implemented in comma::TypeCheck.

Node comma::ParseClient::getInvalidNode (  )  [inline]

Nodes cannot be constructed from outside a parse client. However, the parser needs to be able to create invalid nodes to communicate failures during parsing (just as the ParseClient returns invalid nodes to indicate a semantic failure).

Definition at line 185 of file ParseClient.h.

Node comma::ParseClient::getNode ( void *  ptr  )  [inline, protected]

Allow sub-classes to construct arbitrary nodes.

Definition at line 834 of file ParseClient.h.

Node comma::ParseClient::getNullNode (  )  [inline]

Nodes cannot be constructed from outside a parse client, yet many of the callbacks take null nodes indicateing a non-existant argument. This method is made available to the parser so that it has a means of producing such null nodes.

Definition at line 179 of file ParseClient.h.

Node comma::ParseClient::getReleasedNode ( void *  ptr  )  [inline, protected]

Construct a node which has released its ownership to the associated data.

Definition at line 838 of file ParseClient.h.


The documentation for this class was generated from the following file:

Generated on 1 Feb 2010 for Comma by  doxygen 1.6.1