#charset "us-ascii"
/*
* Copyright (c) 2005, 2006 Michael J. Roberts
*
* This file is part of TADS 3.
*
* This module defines some classes used by the GrammarProd intrinsic
* class.
*/
#include <tads.h>
#include <gramprod.h>
/* ------------------------------------------------------------------------ */
/*
* GrammarProd descriptor classes. The GrammarProd intrinsic class's
* getGrammarInfo() method uses these classes to build its description of
* a grammar production.
*/
/* export the classes so the intrinsic class can find them */
export GrammarAltInfo 'GrammarProd.GrammarAltInfo';
export GrammarAltTokInfo 'GrammarProd.GrammarAltTokInfo';
/*
* Rule alternative descriptor. This describes one alternative in a
* grammar production. An alternative is one complete list of matchable
* tokens.
*
* In a 'grammar' statement, alternatives are delimited by '|' symbols at
* the top level. Each group of tokens set off by '|' symbols is one
* alternative.
*
* When '|' symbols are grouped with parentheses in a 'grammar'
* statement, the compiler "flattens" the grouping by expanding out the
* parenthesized groups until it has entirely top-level alternatives.
* So, at the level of a GrammarProd object, there's no such thing as
* parentheses or nested '|' symbols.
*/
class GrammarAltInfo: object
/*
* Constructor. GrammarProd.getGrammarInfo() calls this once for
* each alternative making up the production, passing in the values
* that define the alternative. Note that we have a '...' in our
* argument list so that we'll be compatible with any future
* GrammarProd versions that add additional arguments - we won't do
* anything with the extra arguments, but we'll harmlessly ignore
* them, so code compiled with this library version will continue to
* work correctly.
*/
construct(score, badness, matchObj, toks, ...)
{
/* stash away the information */
gramBadness = badness;
gramMatchObj = matchObj;
gramTokens = toks;
}
/*
* The 'badness' value associated with the alternative. A value of
* zero means that there's no badness.
*/
gramBadness = 0
/*
* the "match object" class - this is the class that
* GrammarProd.parseTokens() instantiates to represent a match to
* this alternative in the match list that the method returns
*/
gramMatchObj = nil
/*
* The token descriptor list. This is a list of zero or more
* GrammarAltTokInfo objects describing the tokens making up this
* rule.
*/
gramTokens = []
;
/*
* Grammar rule token descriptor. GrammarProd.getGrammarInfo()
* instantiates one of these objects to represent each token slot in an
* alternative; a GrammarAltInfo object's gramTokens property has a list
* of these objects.
*/
class GrammarAltTokInfo: object
/*
* Constructor. GrammarProd.getGrammarInfo() calls this once for
* each token in each alternative in the production, passing in
* values to fully describe the token slot: the target property (in a
* 'grammar' statement, this is the property after a '->' symbol);
* the token type; and extra information that depends on the token
* type. Note that we use '...' at the end of the argument list so
* that we'll be compatible with any future changes to GrammarProd
* that add more arguments to this method.
*/
construct(prop, typ, info, ...)
{
/* remember the information */
gramTargetProp = prop;
gramTokenType = typ;
gramTokenInfo = info;
}
/*
* The target property - this is the property of the *match object*
* that will store the match information for the token. In a
* 'grammar' statement, this is the property after the '->' symbol
* for this token.
*/
gramTargetProp = nil
/*
* The token type. This is one of the GramTokTypeXxx values (see
* gramprod.h) indicating what kind of token slot this is.
*/
gramTokenType = nil
/*
* Detailed information for the token slot, which depends on the
* token type:
*
* GramTokTypeProd - this gives the GrammarProd object defining the
* sub-production that this token slot matches
*
* GramTokTypeSpeech - this is the property ID giving the
* part-of-speech property that this token slot matches
*
* GramTokTypeNSpeech - this is a list of property IDs giving the
* part-of-speech properties that this token slot matches
*
* GramTokTypeLiteral - this is a string giving the literal that this
* slot matches
*
* GramTokTypeTokEnum - this is the enum value giving the token type
* that this slot matches
*
* GramTokTypeStar - no extra information (the value will be nil)
*/
gramTokenInfo = nil
;
/*
* Dynamic match object interface. This is a mix-in class that should be
* used as a superclass for any class used as the match object when
* creating new alternatives dynamically with GrammarProd.addAlt().
*
* This class provides an implementation of grammarInfo() that works like
* the version the compiler generates for static match objects. In this
* case, we use the grammarAltProps information that addAlt() stores in
* the match object.
*/
class DynamicProd: object
/*
* Generate match information. This returns the same information
* that grammarInfo() returns for match objects that the compiler
* generates for static 'grammar' statements.
*/
grammarInfo()
{
return [grammarTag] + grammarAltProps.mapAll({ p: self.(p) });
}
/*
* grammarTag - the name for the collection of alternatives
* associated with the match object. This name is primarily for
* debugging purposes; it appears as the first element of the
* grammarInfo() result list.
*/
grammarTag = 'new-alt'
/*
* grammarAltProps - the list of "->" properties used in all of the
* alternatives associated with this match object. addAlts() stores
* this list automatically - there's no need to create it manually.
*/
grammarAltProps = []
;
Adv3Lite Library Reference Manual
Generated on 03/07/2024 from adv3Lite version 2.1