public static IComparisonWithAdvance CreateVBScriptQuotedString( Options options, string name = null, ILog log = null) { // We can use a pattern comparison to do this // First character is a quote // Subsequent characters can either be anything BUT a single ", or double "" but advance 2. // Although it seems un-intuitive this gives us the behaviour we require: skip double quotes. var isQuote = new CharComparison(log, options, '\"'); // This requires more than one statement StatementList statementList = new StatementList(log); statementList.Name = name; // The pattern comparison that will do the work PatternComparison patternComp = new PatternComparison(log, options); statementList.Add(patternComp); patternComp.MinLength = 2; // First character is open quote var first = new ComparisonRange <IComparisonWithAdvance>(); first.Range.Min = 1; first.Range.Max = 1; first.Comparison = isQuote; patternComp.AddComparisonRange(first); // Subsequent characters var subsequent = new ComparisonRange <IComparisonWithAdvance>(); subsequent.Range.Min = 2; OrComparison isNotSingleQuoteOrIsDoubleQuotesAndAdvance2 = new OrComparison(log); var notQuote = new NotCharComparison(log, isQuote); isNotSingleQuoteOrIsDoubleQuotesAndAdvance2.Add(notQuote); var doubleQuote = new StringComparison(log, options, "\"\""); isNotSingleQuoteOrIsDoubleQuotesAndAdvance2.Add(doubleQuote); subsequent.Comparison = isNotSingleQuoteOrIsDoubleQuotesAndAdvance2; patternComp.AddComparisonRange(subsequent); // End when find the terminating " patternComp.EndComparison = isQuote; // Skip the trailing quote by advancing by 1 statementList.Add(new OffsetAdvance(log, 1)); return(statementList); }
public static IComparisonWithAdvance VBScriptLineWrap( ILog log, Options options) { // In VB script you can have the underscore character which signifies wrapping to the next line. // E.g: // Response.Write _ // (test & _ // args) IOperation skipWhitespace = SkipWhitespace(log); StatementList lineWrap = new StatementList(log); lineWrap.Add(skipWhitespace); var isUnderscore = new CharComparison(log, options, '_'); lineWrap.Add(isUnderscore); lineWrap.Add(skipWhitespace); return(lineWrap); }
public static IComparisonWithAdvance CreateVBScriptSub( Options options, string name = null, ILog log = null) { // This requires more than one statement StatementList statementList = new StatementList(log); statementList.Name = name; // Function end: . , ", or whitespace CharComparison isDot = new CharComparison(log, options, '.'); CharComparison isQuote = new CharComparison(log, options, '\"'); CharDelegateComparison isWhitespace = new CharDelegateComparison(log, Char.IsWhiteSpace); OrComparison funcNameEnd = new OrComparison(log); funcNameEnd.Add(isDot); funcNameEnd.Add(isQuote); funcNameEnd.Add(isWhitespace); // Identifier but not including classes/namespaces var identifier = TokenComparison.CreateIdentifier( options, end: funcNameEnd, exclusion: null, name: null, log: log); // List of identifiers seperated by . which will include classes/namespaces var sub = TokenComparison.CreateListOfTokens( options, token: identifier, segment: isDot, name: null, log: null); statementList.Add(sub); return(statementList); }
public static IComparisonWithAdvance CreateNumber( Options options, IComparisonWithAdvance end, string name = null, ILog log = null) { //// List of 1 or 2 sets of numbers seperated by a . StatementList stmtList = new StatementList(log); stmtList.Name = name; OrComparison isDotOrEnd = new OrComparison(log); isDotOrEnd.Add(end); ICharComparison isDot = new CharComparison(log, options, '.'); isDotOrEnd.Add(isDot); PatternComparison patternComp = new PatternComparison(log, options); patternComp.MinLength = 1; patternComp.EndComparison = isDotOrEnd; // All characters must be between 0 and 9 var allCharacters = new ComparisonRange <IComparisonWithAdvance>(); allCharacters.Range.Min = 1; var isNumber = new CharDelegateComparison(log, Char.IsNumber); allCharacters.Comparison = isNumber; patternComp.AddComparisonRange(allCharacters); // List consisting of 1 or 2 items seperated by . DelimitedListComparison functionName = new DelimitedListComparison(log, options, patternComp, isDot); functionName.MinAmount = 1; functionName.MaxAmount = 2; stmtList.Add(functionName); return(stmtList); }
// Only parse when inside <% %> and not inside double quotes public static List <State> VBScriptState( ILog log, Options parserOptions) { List <State> stateList = new List <State>(); // Page directive state StringComparison insidePageDirective = new StringComparison(log, parserOptions, "<%"); StringComparison outsidePageDirective = new StringComparison(log, parserOptions, "%>"); State insidePageDirectiveState = new State(insidePageDirective, outsidePageDirective, false); stateList.Add(insidePageDirectiveState); // Not inside quotes state CharComparison isQuote = new CharComparison(log, parserOptions, '\"'); State notInsideQuotesState = new State(isQuote, isQuote, true); notInsideQuotesState.Name = "QuoteState"; stateList.Add(notInsideQuotesState); return(stateList); }
// E.g. // class.Function _ \r\n (p1, p2, class.Function2( _\r\n p1,p2 ) ) // or // class.FunctionWithNoArgs // or // variableName public static IComparisonWithAdvance CreateVBScriptFunctionOrVar( Options options, IComparisonWithAdvance vbScriptConcatCommaOrWhitespaceOrEnd, IComparison vbScriptKeywords, string name = null, ILog log = null) { if (options == null) { options = CreateVBScriptParserOptions(log); } if (vbScriptConcatCommaOrWhitespaceOrEnd == null) { vbScriptConcatCommaOrWhitespaceOrEnd = CreateVBScriptConcatCommaOrWhitespaceOrEnd(log); } if (vbScriptKeywords == null) { vbScriptKeywords = TokenComparison.VBScriptKeywords(log, options); } if (options.SkipLineWrapOperation == null) { Parser.ThrowParseError("The line wrap comparison has not been specified. This is mandatory."); } // This requires more than one statement StatementList statementList = new StatementList(log); statementList.Name = name; // Function CharComparison isDot = new CharComparison(log, options, '.'); OrComparison isDotOrParenOrEnd = new OrComparison(log); isDotOrParenOrEnd.Add(isDot); isDotOrParenOrEnd.Add(vbScriptConcatCommaOrWhitespaceOrEnd); CharComparison openParen = new CharComparison(log, options, '('); isDotOrParenOrEnd.Add(openParen); var identifier = TokenComparison.CreateIdentifier( options, end: isDotOrParenOrEnd, exclusion: vbScriptKeywords, name: "identifier", log: log); // List of identifiers seperated by . which will include classes/namespaces var sub = TokenComparison.CreateListOfTokens( options, token: identifier, segment: isDot, name: "sub", log: log); statementList.Add(sub); // Skip whitespace { var skip = SkipWhitespace(log); skip.Name = "SkipWhitespace1"; statementList.Add(skip); } // Skip the line wrap character statementList.Add(options.SkipLineWrapOperation); // Function parenthesis and arguments CharComparison close = new CharComparison(log, options, ')'); // Either the end (and don't advance past it), or function argument list OrComparison isEndOrArgumentList = new OrComparison(log); isEndOrArgumentList.Name = "IsEndOrArgumentList"; isEndOrArgumentList.Add(new CompareNoAdvance(log, vbScriptConcatCommaOrWhitespaceOrEnd)); isEndOrArgumentList.Add(new NestedOpenCloseComparison(log, openParen, close)); statementList.Add(isEndOrArgumentList); return(statementList); }
// From "response.write blah" // To "response.write(blah)" public static string AddParenthesisToFunctionCalls( ILog log, string input, out int numMatches, Action <Action <string, IAssertion> > fCreateAssertList = null) { // The parser object that will do the work Parser parser = new Parser(log); //// Parser options // This create a special line wrap Options parserOptions = TokenComparison.CreateVBScriptParserOptions(log); CharDelegateComparison isWhitespace = new CharDelegateComparison(log, Char.IsWhiteSpace); IOperation skipWhitespace = TokenComparison.SkipWhitespace(log); // State List <State> stateList = VBScriptState(log, parserOptions); // The main statement list StatementList mainStatements = new StatementList(log); // Capturing Dictionary <string, Capture> capturing = new Dictionary <string, Capture>(); // Function name capture Capture funcNameCapture = new Capture(log); funcNameCapture.Name = "FunctionName"; capturing.Add("funcName", funcNameCapture); mainStatements.Add(funcNameCapture); // Function name capture statements var vbScriptKeywords = TokenComparison.VBScriptKeywords(log, parserOptions); StatementList funcNameCaptureStatements = new StatementList(log); funcNameCapture.Comparison = funcNameCaptureStatements; funcNameCaptureStatements.Exclusion = vbScriptKeywords; //// Starts with whitespace or is the start of the input string StartOfInputStringComparison isStartOfString = new StartOfInputStringComparison(log); OrComparison startsWithWhitespaceOrIsStartOfInputString = new OrComparison(log); startsWithWhitespaceOrIsStartOfInputString.Add(isStartOfString); startsWithWhitespaceOrIsStartOfInputString.Add(isWhitespace); funcNameCaptureStatements.Add(startsWithWhitespaceOrIsStartOfInputString); // Skip whitespace funcNameCaptureStatements.Add(skipWhitespace); //// Function/sub name. //// For example: class1.Func or class1.Func"string arg" funcNameCaptureStatements.Add(TokenComparison.CreateVBScriptSub(parserOptions, name: null, log: log)); //// Arguments list // Skip whitespace and don't capture it mainStatements.Add(skipWhitespace); // Capture Capture argListCapture = new Capture(log); capturing.Add("funcArgs", argListCapture); mainStatements.Add(argListCapture); // Function argument list capture statements StatementList argListCaptureStatements = new StatementList(log); argListCapture.Comparison = argListCaptureStatements; // Skip the line wrap (and capture it) argListCaptureStatements.Add(parserOptions.SkipLineWrapOperation); // Concatenated single arguments // Delimited by whitespace, comma & or + var vbScriptConcatCommaOrWhitespaceOrEnd = TokenComparison.CreateVBScriptConcatCommaOrWhitespaceOrEnd(log, parserOptions); // Numbers var numberComparison = TokenComparison.CreateNumber(parserOptions, vbScriptConcatCommaOrWhitespaceOrEnd, "ArgsNumber", log: log); // VB script quoted strings var quotedText = TokenComparison.CreateVBScriptQuotedString(parserOptions, name: "Args quoted text", log: log); // VB script function which could include arguments, or a variable name var VbScriptFunctionOrVar = TokenComparison.CreateVBScriptFunctionOrVar( parserOptions, vbScriptConcatCommaOrWhitespaceOrEnd, vbScriptKeywords, "VbScriptFunctionOrVar", log: log); // Individual arguments // Types OrComparison individualArgumentTypes = new OrComparison(log); individualArgumentTypes.Add(numberComparison); individualArgumentTypes.Add(quotedText); individualArgumentTypes.Add(VbScriptFunctionOrVar); // List delimiter for the individual arguments OrComparison vbScriptConcactOrComma = new OrComparison(log); { var matchAmpersand = new CharComparison(log, parserOptions, '&'); matchAmpersand.Name = "ArgsStringConcatenation"; vbScriptConcactOrComma.Add(matchAmpersand); } vbScriptConcactOrComma.Add(new CharComparison(log, parserOptions, '+')); var isComma = new CharComparison(log, parserOptions, ','); vbScriptConcactOrComma.Add(isComma); DelimitedListComparison individualArgumentList = new DelimitedListComparison( log, parserOptions, individualArgumentTypes, seperator: vbScriptConcactOrComma ); individualArgumentList.MinAmount = 1; individualArgumentList.ItemTrim = skipWhitespace; // The argument list - comma seperated list of function arguments DelimitedListComparison argumentList = new DelimitedListComparison( log, parserOptions, individualArgumentList, seperator: isComma ); argumentList.Name = "ArgumentList"; argumentList.MinAmount = 1; argumentList.ItemTrim = skipWhitespace; argListCaptureStatements.Add(argumentList); Action <RunState> InitRunState = null; if (fCreateAssertList != null) { InitRunState = (runState) => { fCreateAssertList(runState.AddAssertion); }; } const string replaceWith = "'funcName'('funcArgs')"; string replaced = parser.Replace( input, replaceWith, mainStatements, capturing, stateList, out numMatches, null, InitRunState ); return(replaced); }