// parse a collection of statements.
StmtWordListCursor Parse_TopStmt(delIsMemberEnd InIsMemberEnd)
{
StmtElem elem = null;
StmtElemForm sef = StmtElemForm.None;
StmtWordListCursor csr = this.StartCursor.PositionBefore(WhichEdge.LeadEdge);
while (true)
{
csr = csr.Next();
if ((csr == null) || (csr.WordCursor.IsEndOfString == true))
{
break;
}
sef = StmtElem.CalcElemForm(InIsMemberEnd, TopStmt, this, csr);
// skip empty words within the collection of stmts.
if (sef == StmtElemForm.Empty)
{
}
else
{
// sef = StmtElem.CalcElemForm(InIsMemberEnd, TopStmt, this, csr);
elem = new StmtElem(TopStmt, sef, csr);
AddMemberElem(elem);
csr = elem.Parse();
}
}
return(csr);
}
public Stmt(TextLines InLines, StmtTraits InTraits)
{
string stmtText = InLines.ToString();
StmtWordListCursor csr = FirstPass_Common(stmtText, InTraits);
Parse_Common(stmtText, csr, InTraits);
}
private StmtWordListCursor FirstPass_Common(string InStmtText, StmtTraits InTraits)
{
StmtWord topWord = StmtElem.FirstPass(InStmtText, InTraits);
StmtWordListCursor csr = topWord.SubWords.PositionBegin();
return(csr);
}
// If start of function, must scan to close function and the advance to
// delim that follows the function.
// Could be standalone function or the function could be member of
// expression element ( or any other stmt level element. a sentence being most common. )
// When parent elem is an expression, dont return an expression char delimeted
// elem as start of new expression.
// note: no need to be error checking the delimeter at this point.
// The parent element parsing code will do that. Here we just say that
// if the delim is expected within the parent elem the elem is standalone.
// otherwise, the elem is consider a stmt within the stmt.
static StmtElemForm CalcElemForm(
delIsMemberEnd InIsMemberEnd,
Stmt InTopStmt, StmtElem InParent,
StmtWordListCursor InCsr)
{
StmtElemForm sef = StmtElemForm.None;
// the cursor StmtWord has sub words. that is, it is braced. elem form could be
// function, could be expression, ...
if (InCsr.StmtWord.HasSubWords == true)
{
// the next word in the string.
// note: since the word is braced, the next word is the delim only word which
// follows the closing brace. ( see StmtElem_FirstPass processing ).
StmtWordListCursor nxCsr = InCsr.Next();
sef = CalcElemForm_Actual(InIsMemberEnd, InTopStmt, InParent, InCsr, nxCsr.WordCursor);
}
else
{
sef = CalcElemForm_Actual(InIsMemberEnd, InTopStmt, InParent, InCsr, InCsr.WordCursor);
}
return(sef);
}
// a qualified sequence are consecutive words separated by path delim: aa/bb/cc
StmtWordListCursor Parse_QualifiedSequence(delIsMemberEnd InIsMemberEnd)
{
StmtElem elem = null;
StmtElemForm sef = StmtElemForm.None;
StmtWordListCursor csr = this.StartCursor.PositionBefore(WhichEdge.LeadEdge);
while (true)
{
csr = csr.Next();
if ((csr == null) || (csr.WordCursor.IsEndOfString == true))
{
break;
}
sef = StmtElem.CalcElemForm(InIsMemberEnd, TopStmt, this, csr);
elem = new StmtElem(TopStmt, sef, csr);
AddMemberElem(elem);
if (Stmt.ElemFormHasSubElements(elem.ElemForm) == true)
{
csr = Parse_SubElement(csr, elem, null);
}
if (csr.WordCursor.IsPathPart == false)
{
break;
}
}
return(csr);
}
// parse the CSV form element.
// return the WordCursor that terminates the element.
private StmtWordListCursor Parse_CSV(delIsMemberEnd InIsMemberEnd)
{
StmtElem elem = null;
StmtElemForm sef = StmtElemForm.None;
StmtWordListCursor csr = this.StartCursor.PositionBefore(WhichEdge.LeadEdge);
while (true)
{
csr = csr.Next();
if ((csr == null) || (csr.WordCursor.IsEndOfString == true))
{
break;
}
sef = StmtElem.CalcElemForm(InIsMemberEnd, TopStmt, this, csr);
elem = new StmtElem(TopStmt, sef, csr);
AddMemberElem(elem);
if (Stmt.ElemFormHasSubElements(elem.ElemForm) == true)
{
csr = elem.Parse();
}
// the CSV stmt ends when an element is not comma delimeted.
if (csr.WordCursor.DelimClass != DelimClassification.DividerSymbol)
{
break;
}
if (csr.WordCursor.DelimValue != ",")
{
break;
}
}
return(csr);
}
private void Parse_Common(string InStmtText, StmtWordListCursor InCsr, StmtTraits InTraits)
{
StmtWordListCursor csr = null;
mStmtText = InStmtText;
mStmtTraits = InTraits;
csr = InCsr.Next();
if (csr == null)
{
throw new ApplicationException("stmt is empty");
}
// the TopStmt holds a collection of statements.
mTopElem = new StmtElem(this, StmtElemForm.TopStmt, csr);
// parse the collection of statements.
csr = mTopElem.Parse();
#if skip
StmtElemForm sef = StmtElemForm.None;
sef = StmtElem.CalcElemForm(this, null, csr);
mTopElem = new StmtElem(this, sef, csr);
if (Stmt.ElemFormHasSubElements(mTopElem.ElemForm) == true)
{
csr = mTopElem.Parse();
}
#endif
}
// parse the Command form element.
// return the WordCursor that terminates the element.
StmtWordListCursor Parse_Command(delIsMemberEnd InIsMemberEnd)
{
StmtElem elem = null;
StmtElemForm sef = StmtElemForm.None;
StmtWordListCursor csr = this.StartCursor.PositionAfter(WhichEdge.LeadEdge);
while (true)
{
csr = csr.Next();
if ((csr == null) || (csr.WordCursor.IsEndOfString == true))
{
break;
}
sef = StmtElem.CalcElemForm(InIsMemberEnd, TopStmt, this, csr);
elem = new StmtElem(TopStmt, sef, csr);
AddMemberElem(elem);
if (Stmt.ElemFormHasSubElements(elem.ElemForm) == true)
{
csr = elem.Parse(Parse_Command_IsMemberEnd);
}
// the command stmt ends when an element is not space delimeted.
if (csr.WordCursor.DelimClass != DelimClassification.Whitespace)
{
break;
}
}
return(csr);
}
// parse the member elements of the element.
// we know the ElemForm and the TopStmt contains the StmtText and StmtTraits.
// Depending on the ElemForm, advance the WordCursor from word to word in the StmtText
// and build a StmtElem for each word.
public StmtWordListCursor Parse()
{
StmtWordListCursor csr = null;
delIsMemberEnd me = null;
csr = Parse(me);
return(csr);
}
public StmtElem(Stmt InTopStmt)
{
mTopStmt = InTopStmt;
mParent = null;
mElemForm = StmtElemForm.None;
mStartCursor = null;
mCloseCursor = null;
}
/// <summary>
/// Construct the Stmt object from the statement string.
/// </summary>
/// <param name="InString"></param>
public Stmt(string InStmtText)
{
StmtTraits traits = new StmtTraits();
StmtWord topWord = StmtElem.FirstPass(InStmtText, traits);
StmtWordListCursor csr = topWord.SubWords.PositionBegin( );
Parse_Common(InStmtText, csr, traits);
}
/// <summary>
/// Construct the Stmt from string with the cursor position AT the first word
/// of the statement.
/// TextTraits are the traits of the first word cursor.
/// </summary>
/// <param name="InString"></param>
/// <param name="InCsr"></param>
public Stmt(string InStmtText, WordCursor InStartCsr)
{
StmtTraits traits = new StmtTraits(InStartCsr.TextTraits);
StmtWord topWord = StmtElem.FirstPass(InStmtText, InStartCsr, traits);
StmtWordListCursor wlCsr = topWord.SubWords.PositionBegin();
Parse_Common(InStmtText, wlCsr, traits);
}
// calc the elem form based on the isolated delim of the element.
// ( see the caller. the isolated delim is either the direct delim of the
// word in the string, or is the delim that follows a braced word. )
static StmtElemForm CalcElemForm_Actual_Sentence(
delIsMemberEnd InIsMemberEnd,
Stmt InTopStmt, StmtElem InParent,
StmtWordListCursor InCsr,
WordCursor InDelimCursor)
{
StmtElemForm sef = StmtElemForm.None;
if ((InParent != null) && (InParent.IsSentence == true))
{
sef = CalcElemForm_Standalone(InTopStmt, InParent, InCsr);
}
else
{
StmtWordListCursor c2 = null;
sef = StmtElemForm.Sentence;
// lookahead in the stmt string. look to see if the sentence ends with
// a braced section or not.
c2 = InCsr.PositionBefore(WhichEdge.LeadEdge);
while (true)
{
c2 = c2.Next();
if (c2 == null)
{
break;
}
if (c2.StmtWord.HasSubWords == true)
{
if (InTopStmt.StmtTraits.IsSentenceOpenBraceChar(c2.WordCursor.DelimValue) == true)
{
sef = StmtElemForm.BracedSentence;
break;
}
c2 = c2.Next();
}
// word is an assignment symbol. stmt is not a sentence. it is an assignment.
if ((InParent != null) && (InParent.ElemForm != StmtElemForm.lhs))
{
if (c2.WordCursor.DelimIsAssignmentSymbol == true)
{
sef = StmtElemForm.Assignment;
break;
}
}
// last word in the sentence.
if (InTopStmt.StmtTraits.IsSentenceDelim(c2.WordCursor.DelimValue) == false)
{
break;
}
}
}
return(sef);
}
public static StmtElemForm CalcElemForm(
Stmt InTopStmt, StmtElem InParent,
StmtWordListCursor InCsr)
{
StmtElemForm sef = StmtElemForm.None;
delIsMemberEnd me = null;
sef = CalcElemForm(me, InTopStmt, InParent, InCsr);
return(sef);
}
// method called via delegate to know when sub element parsing should end because
// delim is an end of member delim.
bool Parse_Command_IsMemberEnd(StmtWordListCursor InCsr)
{
if (InCsr.WordCursor.DelimIsWhitespace == true)
{
return(true);
}
else
{
return(false);
}
}
public StmtElem(Stmt InTopStmt, StmtElemForm InForm, StmtWordListCursor InStartCursor)
{
if (InForm == StmtElemForm.None)
{
throw new ApplicationException("StmtElem form is not set");
}
mTopStmt = InTopStmt;
mElemForm = InForm;
mStartCursor = InStartCursor;
mCloseCursor = null;
}
StmtWordListCursor Parse(delIsMemberEnd InIsMemberEnd)
{
StmtWordListCursor csr = null;
switch (mElemForm)
{
case StmtElemForm.Function:
csr = Parse_Function(InIsMemberEnd);
break;
case StmtElemForm.Sentence:
csr = Parse_Sentence(InIsMemberEnd);
break;
case StmtElemForm.BracedSentence:
csr = Parse_Sentence(InIsMemberEnd);
break;
case StmtElemForm.BracedContent:
csr = Parse_BracedContent(InIsMemberEnd);
break;
case StmtElemForm.CSV:
csr = Parse_CSV(InIsMemberEnd);
break;
case StmtElemForm.Assignment:
csr = Parse_Assignment(InIsMemberEnd);
break;
case StmtElemForm.ValueExpression:
csr = Parse_ValueExpression(InIsMemberEnd);
break;
case StmtElemForm.Command:
csr = Parse_Command(InIsMemberEnd);
break;
case StmtElemForm.QualifiedSequence:
csr = Parse_QualifiedSequence(InIsMemberEnd);
break;
case StmtElemForm.TopStmt:
csr = Parse_TopStmt(InIsMemberEnd);
break;
default:
throw new ApplicationException("Parse Stmt failed. StmtForm is unsupported.");
}
return(csr);
}
StmtWordListCursor Parse_Assignment(delIsMemberEnd InIsMemberEnd)
{
StmtElem elem = null;
StmtElemForm sef = StmtElemForm.None;
StmtWordListCursor csr = this.StartCursor.PositionBefore(WhichEdge.LeadEdge);
// first word is the lhs of the assignment stmt.
csr = csr.Next();
StmtElem lhsElem = new StmtElem(TopStmt, StmtElemForm.lhs, csr);
AddMemberElem(lhsElem);
// parse the lhs word
sef = StmtElem.CalcElemForm(null, TopStmt, lhsElem, csr);
elem = new StmtElem(TopStmt, sef, csr);
lhsElem.AddMemberElem(elem);
if (Stmt.ElemFormHasSubElements(sef) == true)
{
csr = elem.Parse();
}
// right hand side.
csr = csr.Next();
if ((csr == null) || (csr.WordCursor.IsEndOfString == true))
{
throw new ApplicationException("assignment stmt missing right hand side");
}
StmtElem rhsElem = new StmtElem(TopStmt, StmtElemForm.rhs, csr);
AddMemberElem(rhsElem);
sef = StmtElem.CalcElemForm(InIsMemberEnd, TopStmt, rhsElem, csr);
elem = new StmtElem(TopStmt, sef, csr);
rhsElem.AddMemberElem(elem);
if (Stmt.ElemFormHasSubElements(sef) == true)
{
StmtWordListCursor csr2 = null;
csr2 = elem.Parse();
if (elem.ElemForm == StmtElemForm.Function)
{
csr = csr.Next();
}
else
{
csr = csr2;
}
}
return(csr);
}
// method called via delegate to know when sub element parsing should end because
// delim is an end of member delim.
bool Parse_Function_IsMemberEnd(StmtWordListCursor InCsr)
{
if ((InCsr.WordCursor.DelimClass == DelimClassification.DividerSymbol) &&
(InCsr.WordCursor.DelimValue == ","))
{
return(true);
}
else if ((InCsr.WordCursor.DelimClass == DelimClassification.DividerSymbol) &&
(InCsr.WordCursor.DelimValue == TopStmt.StmtTraits.FunctionCloseBraceChar))
{
return(true);
}
else
{
return(false);
}
}
StmtWordListCursor Parse_ValueExpression(delIsMemberEnd InIsMemberEnd)
{
StmtElem elem = null;
StmtElemForm sef = StmtElemForm.None;
StmtWordListCursor csr = this.StartCursor.PositionBefore(WhichEdge.LeadEdge);
// parse the expression until delim that is not an expression symbol
while (true)
{
csr = csr.Next();
if ((csr == null) || (csr.WordCursor.IsEndOfString == true))
{
break;
}
sef = StmtElem.CalcElemForm(InIsMemberEnd, TopStmt, this, csr);
elem = new StmtElem(TopStmt, sef, csr);
AddMemberElem(elem);
if (Stmt.ElemFormHasSubElements(elem.ElemForm) == true)
{
elem.Parse();
csr = csr.Next();
if (csr == null)
{
break;
}
}
// add the expression string as a operator element of the expression parent.
if (csr.WordCursor.DelimIsExpressionSymbol == true)
{
elem = new StmtElem(TopStmt, StmtElemForm.ExpressionOperator, csr);
AddMemberElem(elem);
}
else
{
break;
}
}
return(csr);
}
// parse the function form element.
// return the WordCursor that terminates the element.
StmtWordListCursor Parse_Function(delIsMemberEnd InIsMemberEnd)
{
StmtWordListCursor csr = null;
StmtElem elem = null;
StmtElemForm sef = StmtElemForm.None;
csr = StartCursor.StmtWord.SubWords.PositionBegin();
while (true)
{
csr = csr.Next();
if (csr == null)
{
break;
}
// new line between function arguments. is ok. treat as whitespace.
else if ((csr.WordCursor.IsDelimOnly == true) &&
(csr.WordCursor.DelimClass == DelimClassification.NewLine))
{
}
// is the closing brace delim of a function with no args.
else if (csr.WordCursor.IsDelimOnly == true)
{
}
// function arg sub element.
else
{
sef = StmtElem.CalcElemForm(Parse_Function_IsMemberEnd, TopStmt, this, csr);
elem = new StmtElem(TopStmt, sef, csr);
AddMemberElem(elem);
if (Stmt.ElemFormHasSubElements(sef) == true)
{
csr = Parse_SubElement(csr, elem, Parse_Function_IsMemberEnd);
}
}
CloseCursor = csr;
}
return(csr);
}
StmtWordListCursor Parse_Sentence(delIsMemberEnd InIsMemberEnd)
{
StmtElem elem = null;
StmtElemForm sef = StmtElemForm.None;
StmtWordListCursor csr = this.StartCursor.PositionBefore(WhichEdge.LeadEdge);
while (true)
{
csr = csr.Next();
if ((csr == null) || (csr.WordCursor.IsEndOfString == true))
{
break;
}
sef = StmtElem.CalcElemForm(InIsMemberEnd, TopStmt, this, csr);
// skip empty words within a sentence ( a newline char sequence )
if (sef == StmtElemForm.Empty)
{
}
else
{
elem = new StmtElem(TopStmt, sef, csr);
AddMemberElem(elem);
if (Stmt.ElemFormHasSubElements(elem.ElemForm) == true)
{
csr = Parse_SubElement(csr, elem, null);
}
}
// the sentence ends when the delim after the sentence member elem is
// not a sentence delim.
if (TopStmt.StmtTraits.IsSentenceDelim(csr.WordCursor.DelimValue) == false)
{
break;
}
}
return(csr);
}
// calc the form of the element without the context of the delim that separates it
// from the next element, and without consideration of the parent elem.
private static StmtElemForm CalcElemForm_Standalone(
Stmt InTopStmt, StmtElem InParent,
StmtWordListCursor InCsr)
{
StmtElemForm form = StmtElemForm.None;
WordCursor wc = InCsr.WordCursor;
if (wc.IsDelimOnly == true)
{
form = StmtElemForm.Empty;
}
else if (wc.WordClassification == WordClassification.OpenNamedBraced)
{
form = StmtElemForm.Function;
}
else if (wc.WordClassification == WordClassification.OpenContentBraced)
{
form = StmtElemForm.BracedContent;
}
else if (wc.WordClassification == WordClassification.Identifier)
{
form = StmtElemForm.Variable;
}
else if (wc.WordClassification == WordClassification.Quoted)
{
form = StmtElemForm.QuotedLiteral;
}
else if (wc.WordClassification == WordClassification.Numeric)
{
form = StmtElemForm.NumericLiteral;
}
else
{
throw new ApplicationException(
"Cannot calc StmtElem form of word " +
wc.Word.ToString() + " starting at position " +
wc.WordBx.ToString());
}
return(form);
}
// parse the sub element, then properly position the StmtWordListCursor to the word
// which follows the sub element.
StmtWordListCursor Parse_SubElement(
StmtWordListCursor InElemCursor, StmtElem InSubElem, delIsMemberEnd InIsMemberEnd)
{
StmtWordListCursor csr2 = null;
StmtWordListCursor elemCursor = InElemCursor;
csr2 = InSubElem.Parse(InIsMemberEnd);
// if the sub element just parsed is an expression, the words of the
// expression were inline ( at the same level ) with the words of this
// Function element.
if ((InSubElem.IsExpression == true) ||
(InSubElem.ElemForm == StmtElemForm.Sentence))
{
elemCursor = csr2;
}
// an assignment stmt. ( should throw if not delim by stmt end delim. )
else if (InSubElem.ElemForm == StmtElemForm.Assignment)
{
elemCursor = csr2;
}
// the sub element is a function. the way the words of the sub function are
// parsed, the closing brace of the sub function will be the delim of the
// last element of the sub function.
// The next word of this owning function ( assuming it is properly formed )
// will be a delim only word where the delim is either "," or close brace.
else if ((InSubElem.ElemForm == StmtElemForm.Function) ||
(InSubElem.ElemForm == StmtElemForm.BracedSentence) ||
(InSubElem.ElemForm == StmtElemForm.BracedContent))
{
elemCursor = elemCursor.Next();
}
return(elemCursor);
}
// braced content consists of a list of statements.
// examples of braced on content:
// string func( arg InFac1 ) { int xx = 5 ; return xx.ToString( ) ; } // two stmts.
// char[] nwc = new char[] { 'a', 'b', 'c' } ; // one stmt.
StmtWordListCursor Parse_BracedContent(delIsMemberEnd InIsMemberEnd)
{
StmtWordListCursor csr = null;
StmtElem elem = null;
StmtElemForm sef = StmtElemForm.None;
csr = StartCursor.StmtWord.SubWords.PositionBegin();
while (true)
{
csr = csr.Next();
if (csr == null)
{
break;
}
// is the closing brace delim of a function with no args.
else if (csr.WordCursor.IsDelimOnly == true)
{
}
// function arg sub element.
else
{
sef = StmtElem.CalcElemForm(Parse_Function_IsMemberEnd, TopStmt, this, csr);
elem = new StmtElem(TopStmt, sef, csr);
AddMemberElem(elem);
if (Stmt.ElemFormHasSubElements(sef) == true)
{
csr = Parse_SubElement(csr, elem, Parse_Function_IsMemberEnd);
}
}
CloseCursor = csr;
}
return(csr);
}
// calc the elem form based on the isolated delim of the element.
// ( see the caller. the isolated delim is either the direct delim of the
// word in the string, or is the delim that follows a braced word. )
static StmtElemForm CalcElemForm_Actual(
delIsMemberEnd InIsMemberEnd,
Stmt InTopStmt, StmtElem InParent,
StmtWordListCursor InCsr,
WordCursor InDelimCursor)
{
StmtElemForm sef = StmtElemForm.None;
// how to handle InParent when InParent is ElemForm == StmtElemForm.TopStmt?
// actual end of text of string.
if ((InDelimCursor.DelimClass == DelimClassification.EndOfString) ||
(InTopStmt.StmtTraits.IsEndStmtDelim(InDelimCursor.DelimValue) == true))
{
if ((InParent != null) && (InParent.ElemForm != StmtElemForm.TopStmt))
{
sef = CalcElemForm_Standalone(InTopStmt, InParent, InCsr);
}
else if (InTopStmt.StmtTraits.HasSentenceDelimStrings == true)
{
sef = StmtElemForm.Sentence;
}
else
{
sef = StmtElemForm.Command;
}
}
// lhs of assignment statement.
else if (InDelimCursor.DelimIsAssignmentSymbol == true)
{
if (InParent == null)
{
sef = StmtElemForm.Assignment;
}
else if ((InParent.ElemForm == StmtElemForm.lhs) ||
(InParent.ParentElemForm == StmtElemForm.lhs))
{
sef = CalcElemForm_Standalone(InTopStmt, InParent, InCsr);
}
else
{
sef = StmtElemForm.Assignment;
}
}
// a qualified name ( a directory path )
else if (InDelimCursor.IsPathPart == true)
{
if (InParent == null)
{
sef = StmtElemForm.QualifiedSequence;
}
else if (InParent.ElemForm == StmtElemForm.QualifiedSequence)
{
sef = CalcElemForm_Standalone(InTopStmt, InParent, InCsr);
}
else
{
sef = StmtElemForm.QualifiedSequence;
}
}
else if ((InDelimCursor.DelimIsPathPart == true) &&
(InDelimCursor.WhitespaceFollowsWord == true))
{
if (InParent == null)
{
sef = StmtElemForm.Command;
}
else if (InParent.ElemForm == StmtElemForm.Command)
{
sef = CalcElemForm_Standalone(InTopStmt, InParent, InCsr);
}
else
{
sef = StmtElemForm.Command;
}
}
// the delim of the StmtWord is an expression symbol. this word is either the
// start of an expression, or a word within an expression.
// ( for now, assume is a value expression. if turns out to be boolean, should
// be able to change the elem form of the expression element. )
else if (InDelimCursor.DelimIsExpressionSymbol == true)
{
if (InParent == null)
{
sef = StmtElemForm.ValueExpression;
}
else if (InParent.IsExpression == true)
{
sef = CalcElemForm_Standalone(InTopStmt, InParent, InCsr);
}
else
{
sef = StmtElemForm.ValueExpression;
}
}
// word is part of a space delim command string
// note: have to set the CommandCapable switch in StmtTraits in order to parse
// commands.
else if ((InTopStmt.StmtTraits.CommandCapable == true) &&
(InDelimCursor.DelimIsWhitespace == true))
{
if (InParent == null)
{
sef = StmtElemForm.Command;
}
else if (InParent.ElemForm == StmtElemForm.Command)
{
sef = CalcElemForm_Standalone(InTopStmt, InParent, InCsr);
}
else
{
sef = StmtElemForm.Command;
}
}
// sentence delimiter.
else if (InTopStmt.StmtTraits.IsSentenceDelim(InDelimCursor.DelimValue) == true)
{
sef = CalcElemForm_Actual_Sentence(
InIsMemberEnd, InTopStmt, InParent, InCsr, InDelimCursor);
}
// comma seperated values
else if (InDelimCursor.DelimValue == ",")
{
if (InParent == null)
{
sef = StmtElemForm.CSV;
}
else if (InParent.CommaIsMemberDelim)
{
sef = CalcElemForm_Standalone(InTopStmt, InParent, InCsr);
}
else if ((InParent.Parent != null) &&
(InParent.Parent.CommaIsMemberDelim))
{
sef = CalcElemForm_Standalone(InTopStmt, InParent, InCsr);
}
else
{
sef = StmtElemForm.CSV;
}
}
else if (InTopStmt.StmtTraits.IsFunctionCloseBrace(InDelimCursor.DelimValue) == true)
{
if (InParent == null)
{
throw new ApplicationException("unexpected close brace char");
}
else if (InParent.ElemForm == StmtElemForm.Function)
{
sef = CalcElemForm_Standalone(InTopStmt, InParent, InCsr);
}
else if ((InParent.ElemForm == StmtElemForm.Sentence) &&
(InParent.ParentElemForm == StmtElemForm.Function))
{
sef = CalcElemForm_Standalone(InTopStmt, InParent, InCsr);
}
else
{
throw new ApplicationException("unexpected function close brace char");
}
}
else if (InTopStmt.StmtTraits.IsSentenceCloseBraceChar(InDelimCursor.DelimValue) == true)
{
if (InParent == null)
{
throw new ApplicationException("unexpected close brace char");
}
else if (InParent.ElemForm == StmtElemForm.Sentence)
{
sef = CalcElemForm_Standalone(InTopStmt, InParent, InCsr);
}
else
{
throw new ApplicationException("unexpected function close brace char");
}
}
return(sef);
}
public StmtWordListCursor PositionBegin()
{
StmtWordListCursor csr = new StmtWordListCursor(this, null, AcRelativePosition.Begin);
return(csr);
}
/// <summary>
/// Construct Stmt object from statement string and TextTraits
/// </summary>
/// <param name="InString"></param>
/// <param name="InTraits">Traits that govern how the statement
/// is parsed.</param>
public Stmt(string InStmtText, StmtTraits InTraits)
{
StmtWordListCursor csr = FirstPass_Common(InStmtText, InTraits);
Parse_Common(InStmtText, csr, InTraits);
}