public bool SignalExternalCommandLineArgs(IList<string> args) { args.RemoveAt(0); //Removes the executable file name cmdLineResult = Parser.Default.ParseArguments<Options>(args.ToArray()); ParseArguments(); return true; }
public static XDoc RetrievePageXDoc(PageBE page, uint pageId, ParserMode mode, string language, bool isInclude, int section, Title relToTitle, bool xhtml, out ParserResult parserResult) { uint contextPageId = pageId; if((mode == ParserMode.VIEW) && (contextPageId != uint.MaxValue) && page.Title.IsTemplate) { // NOTE (steveb): page being rendered is a template and a contextual page was specified; this means we're rendering a global template page PageBE contextPage = GetPageById(contextPageId); if(contextPage == null) { parserResult = new ParserResult(); return null; } parserResult = DekiXmlParser.ParseGlobalTemplate(contextPage, page); } else { parserResult = DekiXmlParser.Parse(page, page.ContentType, language ?? page.Language, page.GetText(DbUtils.CurrentSession), mode, isInclude, section, null, relToTitle); } if(page.Title.IsTemplate && isInclude) { DekiXmlParser.PostProcessTemplateInsertBody(parserResult, page); } // post process tail element DekiXmlParser.PostProcessParserResults(parserResult); // BUGBUGBUG (steveb): we cannot properly restore an old title unless it had a display title set // wrap the result in a content tag and return it to the user XDoc result = new XDoc("content") .Attr("type", parserResult.ContentType) .Attr("etag", page.Etag) .Attr("title", page.CustomTitle ?? page.Title.AsUserFriendlyName()); // check if page contains unsafe content if(mode == ParserMode.EDIT) { result.Attr("unsafe", !DekiScriptLibrary.VerifyXHtml(parserResult.MainBody, true)); } if(xhtml) { result.AddNodes(parserResult.Content); } else { // encode the result as nodes of text foreach(XDoc entry in parserResult.Content.Elements) { if(entry.HasName("body")) { result.Start("body").Attr("target", entry["@target"].AsText).Value(entry.ToInnerXHtml()).End(); } else { result.Elem(entry.Name, entry.ToInnerXHtml()); } } } return result; }
private static void* __CopyValue(ParserResult.__Internal native) { var ret = Marshal.AllocHGlobal(28); global::CppSharp.Parser.ParserResult.__Internal.cctor_1(ret, new global::System.IntPtr(&native)); return ret.ToPointer(); }
private static ParserResult.Internal* __CopyValue(ParserResult.Internal native) { var ret = Marshal.AllocHGlobal(56); CppSharp.Parser.ParserResult.Internal.cctor_1(ret, new global::System.IntPtr(&native)); return (ParserResult.Internal*) ret; }
public void when_called() { before = () => { _parser = Parser.DefaultParser; }; act = () => { _result = _parser.Parse <BasicOptions>(_args); }; context["Given a valid command line for Basic Options"] = () => { const string fileName = @"C:\Temp\MyFileName.txt"; const int lineCount = 25; var dateTime = new DateTime(2018, 08, 11); const OneToFive oneToFive = OneToFive.Four; before = () => { _args = new[] { fileName, "-lc", lineCount.ToString(), "-dt", dateTime.ToString("yyyy-MM-dd"), "-otf", oneToFive.ToString() }; }; it["should return a valid result"] = () => _result.ShouldNotBeNull(); it["should return an Options instance"] = () => _result.Options.ShouldNotBeNull(); it["should map FileName correctly"] = () => _result.Options.FileName.ShouldBe(fileName); it["should map LineCount correctly"] = () => _result.Options.LineCount.ShouldBe(lineCount); it["should return Timestamp correctly"] = () => _result.Options.Timestamp.ShouldBe(dateTime); it["should return OneToFive correctly"] = () => _result.Options.OneToFive.ShouldBe(OneToFive.Four); }; context["Given a valid command line for Basic Options with positional Parameter at the end"] = () => { const string fileName = @"C:\Temp\MyFileName.txt"; const int lineCount = 25; var dateTime = new DateTime(2018, 08, 11); const OneToFive oneToFive = OneToFive.Four; before = () => { _args = new[] { "-lc", lineCount.ToString(), "-dt", dateTime.ToString("yyyy-MM-dd"), "-otf", oneToFive.ToString(), fileName }; }; it["should return a valid result"] = () => _result.ShouldNotBeNull(); it["should return an Options instance"] = () => _result.Options.ShouldNotBeNull(); it["should map FileName correctly"] = () => _result.Options.FileName.ShouldBe(fileName); it["should map LineCount correctly"] = () => _result.Options.LineCount.ShouldBe(lineCount); it["should return Timestamp correctly"] = () => _result.Options.Timestamp.ShouldBe(dateTime); it["should return OneToFive correctly"] = () => _result.Options.OneToFive.ShouldBe(OneToFive.Four); }; context["Given a valid command line for Basic Options with positional Parameter in the middle"] = () => { const string fileName = @"C:\Temp\MyFileName.txt"; const int lineCount = 25; var dateTime = new DateTime(2018, 08, 11); const OneToFive oneToFive = OneToFive.Four; before = () => { _args = new[] { "-lc", lineCount.ToString(), "-dt", dateTime.ToString("yyyy-MM-dd"), "-otf", oneToFive.ToString(), fileName }; }; it["should return a valid result"] = () => _result.ShouldNotBeNull(); it["should return an Options instance"] = () => _result.Options.ShouldNotBeNull(); it["should map FileName correctly"] = () => _result.Options.FileName.ShouldBe(fileName); it["should map LineCount correctly"] = () => _result.Options.LineCount.ShouldBe(lineCount); it["should return Timestamp correctly"] = () => _result.Options.Timestamp.ShouldBe(dateTime); it["should return OneToFive correctly"] = () => _result.Options.OneToFive.ShouldBe(OneToFive.Four); }; }
static int Main(string[] args) { ParserResult <CommandLineArguments> options = null; try { options = Parser.Default.ParseArguments <CommandLineArguments>(args); if (!IsValid(options)) { return(-2); } } catch { Console.WriteLine(); Console.WriteLine("Failed to parse command line arguments. See valid command line arguments below:"); var h = new HelpText { AddDashesToOption = true, AdditionalNewLineAfterOption = true }; h.AddOptions(new CommandLineArguments()); Console.WriteLine(h.ToString()); return(-3); } RedirectConsoleOutput(options.Value.OutputFile); if (!ReadResponseFile(options.Value)) { return(-4); } try { options.Value.ProjectPath = Path.GetFullPath(options.Value.ProjectPath); // We should ignore scripts in assets/WebGLTemplates var ignoredPathsRegex = new Regex(string.Format("assets{0}{0}webgltemplates{0}{0}", Path.DirectorySeparatorChar), RegexOptions.Compiled | RegexOptions.IgnoreCase); var editorSubFolder = String.Format("{0}Editor{0}", Path.DirectorySeparatorChar); var pluginsEditorSubFolder = String.Format("{0}Plugins{0}Editor{0}", Path.DirectorySeparatorChar); var pluginSubFolder = String.Format("{0}Plugins{0}", Path.DirectorySeparatorChar); var allFiles = Directory.GetFiles(Path.Combine(options.Value.ProjectPath, "Assets"), "*.js", SearchOption.AllDirectories).Where(path => !ignoredPathsRegex.IsMatch(path)); var filter = new Regex(string.Format(@"{0}|{1}|{2}", editorSubFolder, pluginSubFolder, pluginsEditorSubFolder).Replace("\\", "\\\\"), RegexOptions.Compiled); var runtimeScripts = allFiles.Where(scriptPath => !filter.IsMatch(scriptPath)).Select(scriptPath => new SourceFile { FileName = scriptPath, Contents = File.ReadAllText(scriptPath) }).ToArray(); var editorScripts = allFiles.Where(scriptPath => scriptPath.Contains(editorSubFolder) && !scriptPath.Contains(pluginsEditorSubFolder)).Select(scriptPath => new SourceFile { FileName = scriptPath, Contents = File.ReadAllText(scriptPath) }).ToArray(); var pluginScripts = allFiles.Where(scriptPath => scriptPath.Contains(pluginSubFolder) && !scriptPath.Contains(pluginsEditorSubFolder)).Select(scriptPath => new SourceFile { FileName = scriptPath, Contents = File.ReadAllText(scriptPath) }).ToArray(); var pluginEditorScritps = allFiles.Where(scriptPath => scriptPath.Contains(pluginsEditorSubFolder)).Select(scriptPath => new SourceFile { FileName = scriptPath, Contents = File.ReadAllText(scriptPath) }).ToArray(); if (!ValidateAssemblyReferences(options)) { return(-1); } if (options.Value.DumpScripts) { DumpScripts("Runtime", runtimeScripts); DumpScripts("Editor", editorScripts); DumpScripts("Plugin", pluginScripts); DumpScripts("Plugin/Editor", pluginEditorScritps); } var converter = new UnityScript2CSharpConverter(options.Value.IgnoreErrors, options.Value.SkipComments, options.Value.ShowOrphanComments); var referencedSymbols = new List <SymbolInfo>(); var errors = new HashSet <CompilerError>(new CompilerErrorComparer()); ConvertScripts(AssemblyType.Runtime, runtimeScripts, converter, options.Value, referencedSymbols, errors); ConvertScripts(AssemblyType.Editor, editorScripts, converter, options.Value, referencedSymbols, errors); ConvertScripts(AssemblyType.RuntimePlugins, pluginScripts, converter, options.Value, referencedSymbols, errors); ConvertScripts(AssemblyType.EditorPlugins, pluginEditorScritps, converter, options.Value, referencedSymbols, errors); ReportConversionFinished(runtimeScripts.Length + editorScripts.Length + pluginScripts.Length, options.Value, referencedSymbols, errors); } catch (Exception ex) { using (WithConsoleColors.SetTo(ConsoleColor.DarkRed, ConsoleColor.Black)) { Console.WriteLine(ex.Message); if (options.Value.Verbose) { Console.WriteLine(); Console.WriteLine(ex.StackTrace); } if (!options.Value.IgnoreErrors) { Console.WriteLine("Consider running converter with '-i' option."); } } return(-5); } return(0); }
private ParserResult(ParserResult.Internal native) : this(__CopyValue(native)) { __ownsNativeInstance = true; }
void OnSourceFileParsed(IList<SourceFile> files, ParserResult result) { OnFileParsed(files.Select(f => f.Path), result); }
public virtual void Calculate(DateTime t1, DateTime t2) { var t1a = t1; var t2a = t2; Logger.OnLogEvent += Logger_OnLogEvent; var seriesBeforeCalc = this.Clone(); //if( this.TimeInterval == TimeSeries.TimeInterval.Irregular) t2a = t2.AddDays(1); // we may need midnight value in the next day. if (this.TimeInterval == TimeSeries.TimeInterval.Daily) { // daily_wrdo_pu needs AdjustStartingDate t1a = this.AdjustStartingDateFromProperties(t1, t2a);// DO DO??? needed?? } Exception error = new Exception(); if (Expression != null && Expression.Trim() != "") { string tmpExpression = Expression; Logger.WriteLine("begin Calculate()"); Expression = ExpressionPreProcessor(); ParserResult result = null; try { result = Parser.Evaluate(this.Expression, t1a, t2a, this.TimeInterval); } catch (Exception e) { Console.WriteLine(e.Message); Logger.WriteLine(e.Message, "ui"); Messages.Add(e.Message); error = e; result = null; } if (result != null && ( result.IsDouble || result.IsInteger )) { // constant expression, need to convert to a Series. Series constant = new Series(); constant.TimeInterval = this.TimeInterval; constant = Math.FillMissingWithZero(constant, t1, t2); if( result.IsDouble) constant = Math.Add(constant, result.Double); else constant = Math.Add(constant, result.Integer); result = new ParserResult(constant); } if (result != null && result.IsSeries) { result.Series.Trim(t1, t2); //var s = result.Series; //result.Series = Math.Subset(s, t1, t2); // trim extra data used for calculations Logger.WriteLine("Calculation result has " + result.Series.Count + " rows"); this.TimeInterval = result.Series.TimeInterval; string tableName = this.Table.TableName; this.Table = result.Series.Table; this.Table.TableName = tableName; if (m_db != null) { // Logger.WriteLine("Setting Flags"); m_db.Quality.SetFlags(this); } this.Table.AcceptChanges();// prevents error releated to Deleted rows from Trim() above. foreach (DataRow row in this.Table.Rows) { row.SetAdded(); // so database will insert these rows. } if (m_db != null) // database is not required for calculations. { //bool canSave = m_db.Server.HasSavePrivilge(this.Table.TableName); // if(canSave) m_db.SaveTimeSeriesTable(this.ID, this, DatabaseSaveOptions.UpdateExisting); Expression = tmpExpression; if (seriesBeforeCalc.TimeInterval != this.TimeInterval || seriesBeforeCalc.Units != this.Units) { Logger.WriteLine("Warning Units or interval has changed."); //if(canSave) m_db.SaveProperties(this); // time interval, units, are dependent on calculation. } } } else { Clear(); Console.WriteLine(error.Message); Logger.WriteLine(error.Message); } Logger.WriteLine("Calculate() completed"); Logger.OnLogEvent -= Logger_OnLogEvent; } }
/** * Parses a piece of Java code that matches a certain grammar rule. * * @param pSource The Java source that should get parsed. * @param pCodeFragmentType The code fragment type defining the grammar * rule that should be used to parse the code * fragment. * @param pErrorMessages If this argument is not <code>null</code> error * messages emited by the parser will be added to * this list. Otherwise these error messages will be * written to <code>System.err</code>. * * @return An object of type <code>JSOParser.ParserResult</code> * containing the root node representing a Java code fragment and * the token stream containing the tokens of the parsed source. * * @ * if parsing the code fragment or creating the AST failes. * @throws RecognitionException * * __TEST__ All parsable code fragments still untested for parser failure. */ private ParserResult parse( ANTLRStringStream pSource, CodeFragmentType pCodeFragmentType, List<String> pErrorMessages) { ParserResult result = new ParserResult(); bool isMessageCollectingEnabled = pErrorMessages != null; mLexer.CharStream = pSource; mLexer.EnableErrorMessageCollection(isMessageCollectingEnabled); TokenRewriteStream tokenRewriteStream = new TokenRewriteStream(mLexer); if (mParser != null) { mParser.TokenStream = tokenRewriteStream; } else { mParser = new JavaParser(tokenRewriteStream); mParser.TreeAdaptor = mAST2JSOMTreeAdaptor; } mParser.EnableErrorMessageCollection(isMessageCollectingEnabled); AST2JSOMTree tree = null; if (pCodeFragmentType == CodeFragmentType.ANNOTATION) { tree = (AST2JSOMTree) mParser.annotation().Tree; } else if (pCodeFragmentType == CodeFragmentType.ASSERT_STATEMENT) { tree = (AST2JSOMTree) mParser.assertStatement().Tree; } else if (pCodeFragmentType == CodeFragmentType.BREAK_STATEMENT) { tree = (AST2JSOMTree) mParser.breakStatement().Tree; } else if (pCodeFragmentType == CodeFragmentType.CLASS_EXTENDS_CLAUSE) { tree = (AST2JSOMTree) mParser.classExtendsClause().Tree; } else if ( pCodeFragmentType == CodeFragmentType.COMPLEX_TYPE_IDENTIFIER) { tree = (AST2JSOMTree) mParser.typeIdent().Tree; } else if (pCodeFragmentType == CodeFragmentType.CONTINUE_STATEMENT) { tree = (AST2JSOMTree) mParser.continueStatement().Tree; } else if (pCodeFragmentType == CodeFragmentType.DO_WHILE_STATEMENT) { tree = (AST2JSOMTree) mParser.doWhileStatement().Tree; } else if (pCodeFragmentType == CodeFragmentType.ENUM_CONSTANT) { tree = (AST2JSOMTree) mParser.enumConstant().Tree; } else if (pCodeFragmentType == CodeFragmentType.EXPRESSION) { tree = (AST2JSOMTree) mParser.expression().Tree; } else if (pCodeFragmentType == CodeFragmentType.EXPRESSION_STATEMENT) { tree = (AST2JSOMTree) mParser.expressionStatement().Tree; } else if (pCodeFragmentType == CodeFragmentType.FOR_STATEMENT) { tree = (AST2JSOMTree) mParser.forStatement().Tree; } else if (pCodeFragmentType == CodeFragmentType.FOREACH_STATEMENT) { tree = (AST2JSOMTree) mParser.forEachStatement().Tree; } else if ( pCodeFragmentType == CodeFragmentType.FORMAL_PARAMETER_LIST) { tree = (AST2JSOMTree) mParser.formalParameterList().Tree; } else if ( pCodeFragmentType == CodeFragmentType.GENERIC_TYPE_ARGUMENT_LIST) { tree = (AST2JSOMTree) mParser.genericTypeArgumentList().Tree; } else if ( pCodeFragmentType == CodeFragmentType.GENERIC_TYPE_PARAMETER_LIST) { tree = (AST2JSOMTree) mParser.genericTypeParameterList().Tree; } else if (pCodeFragmentType == CodeFragmentType.IF_STATEMENT) { tree = (AST2JSOMTree) mParser.ifStatement().Tree; } else if (pCodeFragmentType == CodeFragmentType.IMPLEMENTS_CLAUSE) { tree = (AST2JSOMTree) mParser.implementsClause().Tree; } else if (pCodeFragmentType == CodeFragmentType.IMPORT_DECLARATION) { tree = (AST2JSOMTree) mParser.importDeclaration().Tree; } else if ( pCodeFragmentType == CodeFragmentType.INTERFACE_EXTENDS_CLAUSE) { tree = (AST2JSOMTree) mParser.interfaceExtendsClause().Tree; } else if (pCodeFragmentType == CodeFragmentType.JAVA_SOURCE) { tree = (AST2JSOMTree) mParser.javaSource().Tree; } else if (pCodeFragmentType == CodeFragmentType.LABELED_STATEMENT) { tree = (AST2JSOMTree) mParser.labeledStatement().Tree; } else if (pCodeFragmentType == CodeFragmentType.LOCAL_VARIABLE_DECLARATION) { tree = (AST2JSOMTree) mParser.localVariableDeclaration().Tree; } else if (pCodeFragmentType == CodeFragmentType.MODIFIER_LIST) { tree = (AST2JSOMTree) mParser.modifierList().Tree; } else if (pCodeFragmentType == CodeFragmentType.PRIMITIVE_TYPE) { tree = (AST2JSOMTree) mParser.primitiveType().Tree; } else if (pCodeFragmentType == CodeFragmentType.QUALIFIED_IDENTIFIER) { tree = (AST2JSOMTree) mParser.qualifiedIdentifier().Tree; } else if (pCodeFragmentType == CodeFragmentType.RETURN_STATEMENT) { tree = (AST2JSOMTree) mParser.returnStatement().Tree; } else if (pCodeFragmentType == CodeFragmentType.STATEMENT) { tree = (AST2JSOMTree) mParser.statement().Tree; } else if (pCodeFragmentType == CodeFragmentType.STATEMENT_BLOCK) { tree = (AST2JSOMTree) mParser.block().Tree; } else if (pCodeFragmentType == CodeFragmentType.STATEMENT_BLOCK_ELEMENT) { tree = (AST2JSOMTree) mParser.blockStatement().Tree; } else if (pCodeFragmentType == CodeFragmentType.SWITCH_CASE_LABEL) { tree = (AST2JSOMTree) mParser.switchCaseLabel().Tree; } else if (pCodeFragmentType == CodeFragmentType.SWITCH_DEFAULT_LABEL) { tree = (AST2JSOMTree) mParser.switchDefaultLabel().Tree; } else if (pCodeFragmentType == CodeFragmentType.SWITCH_STATEMENT) { tree = (AST2JSOMTree) mParser.switchStatement().Tree; } else if (pCodeFragmentType == CodeFragmentType.SYNCHRONIZED_STATEMENT) { tree = (AST2JSOMTree) mParser.synchronizedStatement().Tree; } else if (pCodeFragmentType == CodeFragmentType.THROW_STATEMENT) { tree = (AST2JSOMTree) mParser.throwStatement().Tree; } else if (pCodeFragmentType == CodeFragmentType.THROWS_CLAUSE) { tree = (AST2JSOMTree) mParser.throwsClause().Tree; } else if (pCodeFragmentType == CodeFragmentType.TRY_STATEMENT) { tree = (AST2JSOMTree) mParser.tryStatement().Tree; } else if (pCodeFragmentType == CodeFragmentType.TRY_STATEMENT_CATCH_CLAUSE) { tree = (AST2JSOMTree) mParser.catchClause().Tree; } else if (pCodeFragmentType == CodeFragmentType.TYPE) { tree = (AST2JSOMTree) mParser.type().Tree; } else if (pCodeFragmentType == CodeFragmentType.TYPE_DECLARATION) { tree = (AST2JSOMTree) mParser.typeDeclaration().Tree; } else if (pCodeFragmentType == CodeFragmentType.VARIABLE_DECLARATOR_IDENTIFIER) { // Simply use the grammar rule for local variables. tree = (AST2JSOMTree) mParser.variableDeclaratorId().Tree; } else if (pCodeFragmentType == CodeFragmentType.VARIABLE_INITIALIZER) { tree = (AST2JSOMTree) mParser.variableInitializer().Tree; } else if (pCodeFragmentType == CodeFragmentType.WHILE_STATEMENT) { tree = (AST2JSOMTree) mParser.whileStatement().Tree; } else if (pCodeFragmentType != null) { throw new JSourceUnmarshallerException( UnmarshallerMessages .getUnsupportedCodeFragmentTypeMessage( pCodeFragmentType)); } else { // TODO Internationalize the message. throw new JSourceUnmarshallerException( "The argument stating the code fragment type mustn't be " + "'null'"); } // On parser errors the generated parser may return something // undefined rather than 'null'. if (!mParser.HasErrors()) { // TODO It seems that the JSourceObjectizer uses the parser result // instead of the tree parser result. CHECK THIS! CommonTreeNodeStream treeNodes = new CommonTreeNodeStream(mAST2JSOMTreeAdaptor, tree); treeNodes.TokenStream = tokenRewriteStream; if (mTreeParser != null) { mTreeParser.Reset(); mTreeParser.SetTreeNodeStream(treeNodes); } else { mTreeParser = new JavaTreeParser(treeNodes); } mTreeParser.EnableErrorMessageCollection( isMessageCollectingEnabled); if (pCodeFragmentType == CodeFragmentType.ANNOTATION) { mTreeParser.annotation(); } else if ( pCodeFragmentType == CodeFragmentType.COMPLEX_TYPE_IDENTIFIER) { mTreeParser.typeIdent(); } else if (pCodeFragmentType == CodeFragmentType.ENUM_CONSTANT) { mTreeParser.enumConstant(); } else if (pCodeFragmentType == CodeFragmentType.EXPRESSION) { mTreeParser.expression(); } else if ( pCodeFragmentType == CodeFragmentType.CLASS_EXTENDS_CLAUSE || pCodeFragmentType == CodeFragmentType.INTERFACE_EXTENDS_CLAUSE) { mTreeParser.extendsClause(); } else if ( pCodeFragmentType == CodeFragmentType.FORMAL_PARAMETER_LIST) { mTreeParser.formalParameterList(); } else if ( pCodeFragmentType == CodeFragmentType.GENERIC_TYPE_ARGUMENT_LIST) { mTreeParser.genericTypeArgumentList(); } else if ( pCodeFragmentType == CodeFragmentType.GENERIC_TYPE_PARAMETER_LIST) { mTreeParser.genericTypeParameterList(); } else if ( pCodeFragmentType == CodeFragmentType.IMPLEMENTS_CLAUSE) { mTreeParser.implementsClause(); } else if ( pCodeFragmentType == CodeFragmentType.IMPORT_DECLARATION) { mTreeParser.importDeclaration(); } else if (pCodeFragmentType == CodeFragmentType.JAVA_SOURCE) { mTreeParser.javaSource(); } else if (pCodeFragmentType == CodeFragmentType.LOCAL_VARIABLE_DECLARATION) { mTreeParser.localVariableDeclaration(); } else if (pCodeFragmentType == CodeFragmentType.MODIFIER_LIST) { mTreeParser.modifierList(); } else if (pCodeFragmentType == CodeFragmentType.PRIMITIVE_TYPE) { mTreeParser.primitiveType(); } else if ( pCodeFragmentType == CodeFragmentType.QUALIFIED_IDENTIFIER) { mTreeParser.qualifiedIdentifier(); } else if ( pCodeFragmentType == CodeFragmentType.STATEMENT || pCodeFragmentType == CodeFragmentType.ASSERT_STATEMENT || pCodeFragmentType == CodeFragmentType.BREAK_STATEMENT || pCodeFragmentType == CodeFragmentType.CONTINUE_STATEMENT || pCodeFragmentType == CodeFragmentType.DO_WHILE_STATEMENT || pCodeFragmentType == CodeFragmentType.EXPRESSION_STATEMENT || pCodeFragmentType == CodeFragmentType.FOR_STATEMENT || pCodeFragmentType == CodeFragmentType.FOREACH_STATEMENT || pCodeFragmentType == CodeFragmentType.IF_STATEMENT || pCodeFragmentType == CodeFragmentType.LABELED_STATEMENT || pCodeFragmentType == CodeFragmentType.RETURN_STATEMENT || pCodeFragmentType == CodeFragmentType.SWITCH_STATEMENT || pCodeFragmentType == CodeFragmentType.SYNCHRONIZED_STATEMENT || pCodeFragmentType == CodeFragmentType.THROW_STATEMENT || pCodeFragmentType == CodeFragmentType.TRY_STATEMENT || pCodeFragmentType == CodeFragmentType.WHILE_STATEMENT) { mTreeParser.statement(); } else if (pCodeFragmentType == CodeFragmentType.SWITCH_CASE_LABEL) { mTreeParser.switchCaseLabel(); } else if (pCodeFragmentType == CodeFragmentType.SWITCH_DEFAULT_LABEL) { mTreeParser.switchDefaultLabel(); } else if (pCodeFragmentType == CodeFragmentType.STATEMENT_BLOCK) { mTreeParser.block(); } else if (pCodeFragmentType == CodeFragmentType.STATEMENT_BLOCK_ELEMENT) { mTreeParser.blockStatement(); } else if (pCodeFragmentType == CodeFragmentType.THROWS_CLAUSE) { mTreeParser.throwsClause(); } else if (pCodeFragmentType == CodeFragmentType.TRY_STATEMENT_CATCH_CLAUSE) { mTreeParser.catchClause(); } else if (pCodeFragmentType == CodeFragmentType.TYPE) { mTreeParser.type(); } else if (pCodeFragmentType == CodeFragmentType.TYPE_DECLARATION) { mTreeParser.typeDeclaration(); } else if (pCodeFragmentType == CodeFragmentType.VARIABLE_DECLARATOR_IDENTIFIER) { mTreeParser.variableDeclaratorId(); } else if (pCodeFragmentType == CodeFragmentType.VARIABLE_INITIALIZER) { mTreeParser.variableInitializer(); } else if (pCodeFragmentType != null) { throw new JSourceUnmarshallerException( UnmarshallerMessages .getUnsupportedCodeFragmentTypeMessage( pCodeFragmentType)); } else { // TODO Internationalize the message. throw new JSourceUnmarshallerException( "The argument stating the code fragment type mustn't be " + "'null'"); } result.mLineCount = mLexer.Line; result.mTokenRewriteStream = tokenRewriteStream; result.mTree = tree; } return result; }
/** * Parses a piece of Java code that matches a certain grammar rule. * * @param pCodeFragment The Java code fragment that should get parsed. * @param pCodeFragmentType The code fragment type defining the grammar * rule that should be used to parse the code * fragment. * @param pErrorMessages If this argument is not <code>null</code> error * messages emited by the parser will be added to * this list. Otherwise these error messages will be * written to <code>System.err</code>. * * @return An object of type <code>JSOParser.ParserResult</code> * containing the root node representing a Java code fragment and * the token stream containing the tokens of the parsed source. If * parsing the code fragment has been failed but no exception * has been thrown <code>null</code> will be returned and it's * very likely that there's at least one message within the message * list passed to this method (if a list has been passed at all, of * course). * * @ if parsing the code fragment * failed. */ protected ParserResult parse( String pCodeFragment, CodeFragmentType pCodeFragmentType, List<String> pErrorMessages) { ParserResult result = new ParserResult(); try { result = parse( new ANTLRStringStream(pCodeFragment), pCodeFragmentType, pErrorMessages); } catch (RecognitionException re) { throw new JSourceUnmarshallerException( UnmarshallerMessages .getJavaCodeFragmentParsingFailedMessage( pCodeFragment, pCodeFragmentType), re); } catch (JSourceUnmarshallerException jsue) { // Just catch 'JSourceUnmarshallerException' exceptions in order to // avoid jumping into the following 'catch' block. throw jsue; } catch (Exception e) { throw new JSourceUnmarshallerException( UnmarshallerMessages .getJavaCodeFragmentParsingFailedMessage( pCodeFragment, pCodeFragmentType), e); } finally { if (pErrorMessages != null) { List<String> parserMessages; bool isMessageHeaderEnabled = true; parserMessages = mLexer.GetMessages(); if (parserMessages.Count > 0) { pErrorMessages.Add( UnmarshallerMessages .getParserMessagesEmitedForCodeFragmentMessage( pCodeFragment, pCodeFragmentType)); isMessageHeaderEnabled = false; foreach (String message in parserMessages) { pErrorMessages.Add( UnmarshallerMessages .getLexerMessageMessage() + message); } } if (mParser != null) { parserMessages = mParser.GetMessages(); if (parserMessages.Count > 0) { if (isMessageHeaderEnabled) { pErrorMessages.Add( UnmarshallerMessages .getParserMessagesEmitedForCodeFragmentMessage( pCodeFragment, pCodeFragmentType)); } isMessageHeaderEnabled = false; foreach (String message in parserMessages) { pErrorMessages.Add( UnmarshallerMessages .getParserMessageMessage() + message); } } } if (mTreeParser != null) { parserMessages = mTreeParser.GetMessages(); if (parserMessages.Count > 0) { if (isMessageHeaderEnabled) { pErrorMessages.Add( UnmarshallerMessages .getParserMessagesEmitedForCodeFragmentMessage( pCodeFragment, pCodeFragmentType)); } foreach (String message in parserMessages) { String TEST_STR = "JavaTreeParser.g: "; int offset = message.IndexOf(TEST_STR); if (offset != -1) { pErrorMessages.Add( UnmarshallerMessages .getTreeParserMessageMessage() + message.Substring( offset + TEST_STR.Length)); } else { pErrorMessages.Add( UnmarshallerMessages .getTreeParserMessageMessage() + message); } } } } } } if (result.mTree != null) { return result; } return null; }
// Process comparison operators void EvalExp1Comparison(out ParserResult result) { string comp; ParserResult partialResult; Eval2Add(out result); while ((comp = token) == ">" || comp == "<") { stack.Add(" comparison : " + comp); GetToken(); Eval2Add(out partialResult); if (Debug && result.IsSeries && partialResult.IsSeries) { Console.WriteLine("Part A "); partialResult.Series.WriteToConsole(); Console.WriteLine("Part B"); result.Series.WriteToConsole(); } switch (comp) { case ">": result = result.GreaterThan(partialResult); break; case "<": result = result.LessThan(partialResult); break; } if ((Debug && result.IsSeries && partialResult.IsSeries)) { Console.WriteLine("Part A " + comp + " Part B "); result.Series.WriteToConsole(); } } //Eval2Add(out result); }
// Process a parenthesized expression. void Eval6Parenthesis(out ParserResult result) { if ((token == "(")) { stack.Add("opening parenthesis ( "); GetToken(); Eval2Add(out result); if (token != ")") SyntaxErr(Errors.UNBALPARENS); GetToken(); } else Atom(out result); }
// Evaluate a unary + or -. void Eval5Sign(out ParserResult result) { string op; op = ""; if ((tokType == Types.DELIMITER) && token == "+" || token == "-") { stack.Add(" operator : "+token); op = token; GetToken(); } Eval6Parenthesis(out result); if (op == "-") result = new ParserResult(-1) * result; }
// Process an exponent. void Eval4Exponent(out ParserResult result) { ParserResult partialResult; Eval5Sign(out result); if (token == "^") { stack.Add(" exponent: ^"); GetToken(); Eval4Exponent(out partialResult); result = ParserResult.Pow(result, partialResult); } }
public void ParseTest(ParserResult expect, List <string> parameters, bool upperCaseKeys, bool trimQuotes) { this.AssertParseTestEqual(expect, parameters, upperCaseKeys, trimQuotes); }
private static int Main(string[] args) { WriteLine($"Roslynator Command Line Tool version {typeof(Program).GetTypeInfo().Assembly.GetName().Version}", Verbosity.Quiet); WriteLine("Copyright (c) Josef Pihrt. All rights reserved.", Verbosity.Quiet); WriteLine(Verbosity.Quiet); try { ParserResult <object> parserResult = Parser.Default.ParseArguments < #if DEBUG AnalyzeAssemblyCommandLineOptions, FindSymbolsCommandLineOptions, SlnListCommandLineOptions, ListVisualStudioCommandLineOptions, GenerateSourceReferencesCommandLineOptions, #endif FixCommandLineOptions, AnalyzeCommandLineOptions, ListSymbolsCommandLineOptions, FormatCommandLineOptions, PhysicalLinesOfCodeCommandLineOptions, LogicalLinesOfCodeCommandLineOptions, GenerateDocCommandLineOptions, GenerateDocRootCommandLineOptions>(args); bool verbosityParsed = false; parserResult.WithParsed <AbstractCommandLineOptions>(options => { var defaultVerbosity = Verbosity.Normal; if (options.Verbosity == null || TryParseVerbosity(options.Verbosity, out defaultVerbosity)) { ConsoleOut.Verbosity = defaultVerbosity; Verbosity fileLogVerbosity = defaultVerbosity; if (options.FileLogVerbosity == null || TryParseVerbosity(options.FileLogVerbosity, out fileLogVerbosity)) { if (options.FileLog != null) { var fs = new FileStream(options.FileLog, FileMode.Create, FileAccess.Write, FileShare.Read); var sw = new StreamWriter(fs, Encoding.UTF8, bufferSize: 4096, leaveOpen: false); Out = new TextWriterWithVerbosity(sw) { Verbosity = fileLogVerbosity }; } verbosityParsed = true; } } }); if (!verbosityParsed) { return(1); } return(parserResult.MapResult( #if DEBUG (AnalyzeAssemblyCommandLineOptions options) => AnalyzeAssembly(options), (FindSymbolsCommandLineOptions options) => FindSymbolsAsync(options).Result, (SlnListCommandLineOptions options) => SlnListAsync(options).Result, (ListVisualStudioCommandLineOptions options) => ListVisualStudio(options), (GenerateSourceReferencesCommandLineOptions options) => GenerateSourceReferencesAsync(options).Result, #endif (FixCommandLineOptions options) => FixAsync(options).Result, (AnalyzeCommandLineOptions options) => AnalyzeAsync(options).Result, (ListSymbolsCommandLineOptions options) => ListSymbolsAsync(options).Result, (FormatCommandLineOptions options) => FormatAsync(options).Result, (PhysicalLinesOfCodeCommandLineOptions options) => PhysicalLinesOfCodeAsync(options).Result, (LogicalLinesOfCodeCommandLineOptions options) => LogicalLinesOrCodeAsync(options).Result, (GenerateDocCommandLineOptions options) => GenerateDocAsync(options).Result, (GenerateDocRootCommandLineOptions options) => GenerateDocRootAsync(options).Result, _ => 1)); } catch (Exception ex) { if (ex is AggregateException aggregateException) { foreach (Exception innerException in aggregateException.InnerExceptions) { WriteError(innerException); } } else if (ex is FileNotFoundException || ex is InvalidOperationException) { WriteError(ex); } else { throw; } } finally { Out?.Dispose(); Out = null; #if DEBUG if (Debugger.IsAttached) { Console.ReadKey(); } #endif } return(1); }
internal ParserResult(ParserResult.Internal native) : this(&native) { }
protected bool ParsedTest() { ParserResult root = ISequencer <T> .Parse( "[version: ][i/code: ][message:\r\n][<headers:\r\n\r\n>][name::][|value|:\r\n|$][</>][$|body|$]", "HTTP/1.1 404 Not found\r\nHeader1: data1\r\nCookie: theme=light; sessionToken=abc123\r\nHeaderMultiple: x 1\r\nHeaderMultiple: x 2\r\nHeaderMultiple: x 3\r\nHeader2: data2\r\nHeader3: data3\r\nHeader4: data4\r\n\r\n Hello! This is the body!".GetBytes() ).Close(); if (IsVerbose) { Console.WriteLine(":: ParsedTest"); Console.WriteLine(" :!*********************: headers.<$name=HeaderMultiple$>.value"); foreach (var e in root.GetAll <string>("headers.<$name=HeaderMultiple$>.value")) { Console.WriteLine(" :!: " + e); } Console.WriteLine(" :!*********************: "); Console.WriteLine("Version :"); Console.WriteLine(root["version"]); Console.WriteLine("Code :"); Console.WriteLine(root["code"]); Console.WriteLine("Message :"); Console.WriteLine(root["message"]); Console.WriteLine("Headers :"); foreach (var e in root.GetList("headers")) { Console.WriteLine(e["name"] + " = " + e["value"] + "|"); } Console.WriteLine("Cookies :"); var cookies = ByteSequencer.Parse( "[<cookies:$>][|name|:=][value:;|$][</>]", root.GetString("headers.<|name=cookie|>.value") ).Close(); foreach (var e in cookies.GetList("cookies")) { Console.WriteLine(e["name"] + " //=// " + e["value"]); } Console.WriteLine("Body :"); Console.WriteLine(root["body"]); } if (!root["version"].Equals("HTTP/1.1")) { return(false); } if (!root["code"].Equals(404)) { return(false); } if (!root["message"].Equals("Not found")) { return(false); } if (!root["headers.<0>.name"].Equals("Header1")) { return(false); } if (!root["headers.<0>.value"].Equals("data1")) { return(false); } if (!root["headers.<5>.name"].Equals("Header2")) { return(false); } if (!root["headers.<5>.value"].Equals("data2")) { return(false); } if (!root["headers.<6>.name"].Equals("Header3")) { return(false); } if (!root["headers.<6>.value"].Equals("data3")) { return(false); } if (!root["headers.<7>.name"].Equals("Header4")) { return(false); } if (!root["headers.<7>.value"].Equals("data4")) { return(false); } if (!root["body"].Equals("Hello! This is the body!")) { return(false); } return(true); }
protected override void HandleValue(ServerContext context, ParserResult result) { var input = ""; var selection = ' '; Console.WriteLine(); Console.WriteLine(Strings.Migration.selectdb); Console.WriteLine(); Console.WriteLine( Strings.Migration.selectgamedb.ToString( Options.GameDb.Type == DatabaseOptions.DatabaseType.sqlite ? Strings.Migration.currentlysqlite : Strings.Migration.currentlymysql ) ); Console.WriteLine( Strings.Migration.selectplayerdb.ToString( Options.PlayerDb.Type == DatabaseOptions.DatabaseType.sqlite ? Strings.Migration.currentlysqlite : Strings.Migration.currentlymysql ) ); Console.WriteLine(); Console.WriteLine(Strings.Migration.cancel); // TODO: Remove > when moving to ReadKeyWait when console magic is ready Console.Write("> "); input = Console.ReadLine(); selection = input.Length > 0 ? input[0] : ' '; Console.WriteLine(); DatabaseOptions db; if (selection.ToString() == Strings.Migration.selectgamedbkey.ToString()) { db = Options.GameDb; } else if (selection.ToString() == Strings.Migration.selectplayerdbkey.ToString()) { db = Options.PlayerDb; } else { Console.WriteLine(Strings.Migration.migrationcancelled); return; } var dbString = db == Options.GameDb ? Strings.Migration.gamedb : Strings.Migration.playerdb; Console.WriteLine(); Console.WriteLine(Strings.Migration.selectdbengine.ToString(dbString)); Console.WriteLine(Strings.Migration.migratetosqlite); Console.WriteLine(Strings.Migration.migratetomysql); Console.WriteLine(); Console.WriteLine(Strings.Migration.cancel); // TODO: Remove > when moving to ReadKeyWait when console magic is ready Console.Write("> "); input = Console.ReadLine(); selection = input.Length > 0 ? input[0] : ' '; Console.WriteLine(); var dbengine = DatabaseOptions.DatabaseType.sqlite; if (selection.ToString() != Strings.Migration.selectsqlitekey.ToString() && selection.ToString() != Strings.Migration.selectmysqlkey.ToString()) { Console.WriteLine(Strings.Migration.migrationcancelled); return; } if (selection.ToString() == Strings.Migration.selectmysqlkey.ToString()) { dbengine = DatabaseOptions.DatabaseType.mysql; } if (db.Type == dbengine) { var engineString = dbengine == DatabaseOptions.DatabaseType.sqlite ? Strings.Migration.sqlite : Strings.Migration.mysql; Console.WriteLine(); Console.WriteLine(Strings.Migration.alreadyusingengine.ToString(dbString, engineString)); Console.WriteLine(); } else { try { DbInterface.Migrate(db, dbengine); } catch (Exception exception) { Log.Error(exception); } } }
protected override void HandleValue(ServerContext context, ParserResult result) { NetDebug.GenerateDebugFile(); }
public static void Main(string[] args) { CommandLineOptions clOptions = null; if (args.Length > 0) { ParserResult <CommandLineOptions> result = Parser.Default.ParseArguments <CommandLineOptions>(args).WithParsed(options => { clOptions = options; }); if (result.Tag == ParserResultType.NotParsed) { HelpText.AutoBuild(result); return; } } else { FreeConsole(); bytePatchManager = new BytePatchManager(MessageBox.Show); guiApp = new Application(); guiApp.Run(guiWindow = new PatcherGui()); return; } if (clOptions == null) { return; } bytePatchManager = new BytePatchManager(CustomConsoleWrite); List <string> applicationPaths = new List <string>(); List <int> groups = new List <int>(clOptions.Groups); if (groups.Count == 0) { Console.WriteLine("Groups need to be defined. Use --help for help."); return; } if (clOptions.CustomPath != null && clOptions.CustomPath.Length > 0) { if (!Directory.Exists(clOptions.CustomPath)) { Console.WriteLine("CustomPath not found"); return; } applicationPaths.AddRange(new CustomPath(clOptions.CustomPath).FindDllFiles()); } else { applicationPaths.AddRange(new InstallationFinder.InstallationManager().FindAllChromiumInstallations()); } foreach (GuiPatchGroupData patchData in bytePatchManager.PatchGroups) { if (!groups.Contains(patchData.Group)) { bytePatchManager.DisabledGroups.Add(patchData.Group); } } if (applicationPaths.Count == 0) { Console.WriteLine("Error: No patchable dll file found!"); } foreach (string path in applicationPaths) { try { DllPatcher patcher = new DllPatcher(path); patcher.Patch(Console.WriteLine); } catch (Exception ex) { Console.WriteLine("Error while patching " + path + ":" + ex.Message); } } if (!clOptions.NoWait) { Thread.Sleep(5000); // Wait a bit to let the user see the result } }
public static TResult MapResult <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, TResult>( this ParserResult <object> result, Func <T1, TResult> parsedFunc1, Func <T2, TResult> parsedFunc2, Func <T3, TResult> parsedFunc3, Func <T4, TResult> parsedFunc4, Func <T5, TResult> parsedFunc5, Func <T6, TResult> parsedFunc6, Func <T7, TResult> parsedFunc7, Func <T8, TResult> parsedFunc8, Func <T9, TResult> parsedFunc9, Func <T10, TResult> parsedFunc10, Func <T11, TResult> parsedFunc11, Func <T12, TResult> parsedFunc12, Func <T13, TResult> parsedFunc13, Func <T14, TResult> parsedFunc14, Func <T15, TResult> parsedFunc15, Func <T16, TResult> parsedFunc16, Func <T17, TResult> parsedFunc17, Func <T18, TResult> parsedFunc18, Func <T19, TResult> parsedFunc19, Func <T20, TResult> parsedFunc20, Func <T21, TResult> parsedFunc21, Func <T22, TResult> parsedFunc22, Func <T23, TResult> parsedFunc23, Func <T24, TResult> parsedFunc24, Func <T25, TResult> parsedFunc25, Func <T26, TResult> parsedFunc26, Func <T27, TResult> parsedFunc27, Func <T28, TResult> parsedFunc28, Func <T29, TResult> parsedFunc29, Func <T30, TResult> parsedFunc30, Func <T31, TResult> parsedFunc31, Func <T32, TResult> parsedFunc32, Func <T33, TResult> parsedFunc33, Func <IEnumerable <Error>, TResult> notParsedFunc) { if (!(result is Parsed <object> parsed)) { return(notParsedFunc(((NotParsed <object>)result).Errors)); } if (parsed.Value is T1) { return(parsedFunc1((T1)parsed.Value)); } if (parsed.Value is T2) { return(parsedFunc2((T2)parsed.Value)); } if (parsed.Value is T3) { return(parsedFunc3((T3)parsed.Value)); } if (parsed.Value is T4) { return(parsedFunc4((T4)parsed.Value)); } if (parsed.Value is T5) { return(parsedFunc5((T5)parsed.Value)); } if (parsed.Value is T6) { return(parsedFunc6((T6)parsed.Value)); } if (parsed.Value is T7) { return(parsedFunc7((T7)parsed.Value)); } if (parsed.Value is T8) { return(parsedFunc8((T8)parsed.Value)); } if (parsed.Value is T9) { return(parsedFunc9((T9)parsed.Value)); } if (parsed.Value is T10) { return(parsedFunc10((T10)parsed.Value)); } if (parsed.Value is T11) { return(parsedFunc11((T11)parsed.Value)); } if (parsed.Value is T12) { return(parsedFunc12((T12)parsed.Value)); } if (parsed.Value is T13) { return(parsedFunc13((T13)parsed.Value)); } if (parsed.Value is T14) { return(parsedFunc14((T14)parsed.Value)); } if (parsed.Value is T15) { return(parsedFunc15((T15)parsed.Value)); } if (parsed.Value is T16) { return(parsedFunc16((T16)parsed.Value)); } if (parsed.Value is T17) { return(parsedFunc17((T17)parsed.Value)); } if (parsed.Value is T18) { return(parsedFunc18((T18)parsed.Value)); } if (parsed.Value is T19) { return(parsedFunc19((T19)parsed.Value)); } if (parsed.Value is T20) { return(parsedFunc20((T20)parsed.Value)); } if (parsed.Value is T21) { return(parsedFunc21((T21)parsed.Value)); } if (parsed.Value is T22) { return(parsedFunc22((T22)parsed.Value)); } if (parsed.Value is T23) { return(parsedFunc23((T23)parsed.Value)); } if (parsed.Value is T24) { return(parsedFunc24((T24)parsed.Value)); } if (parsed.Value is T25) { return(parsedFunc25((T25)parsed.Value)); } if (parsed.Value is T26) { return(parsedFunc26((T26)parsed.Value)); } if (parsed.Value is T27) { return(parsedFunc27((T27)parsed.Value)); } if (parsed.Value is T28) { return(parsedFunc28((T28)parsed.Value)); } if (parsed.Value is T29) { return(parsedFunc29((T29)parsed.Value)); } if (parsed.Value is T30) { return(parsedFunc30((T30)parsed.Value)); } if (parsed.Value is T31) { return(parsedFunc31((T31)parsed.Value)); } if (parsed.Value is T32) { return(parsedFunc32((T32)parsed.Value)); } if (parsed.Value is T33) { return(parsedFunc33((T33)parsed.Value)); } throw new InvalidOperationException(); }
static void Main(string[] args) { CommandLineOpts opts = new CommandLineOpts(); ParserResult <CommandLineOpts> result = CommandLine.Parser.Default.ParseArguments <CommandLineOpts>(args) .WithParsed <CommandLineOpts>(options => RunWithOptions(options)); }
protected ParserResult(ParserResult.Internal* native, bool skipVTables = false) { if (native == null) return; __Instance = new global::System.IntPtr(native); }
public Test() { string data = $"Ok, there are some important dates for us.\n " + $"First is 23-10-2002. The second two are: 23/11/2002 and 24/10/02. " + $"Do we have to watch crefully also these three: 10/23/2002, 23/11/2002 and 24/10/02? " + $"I believe some dates may mean nothing, for example: Oct 23,20002 and October 23, 2002. " + $"i think we all rule for participating. Was my brother born at 23 Oct 2002? Yes, mother at 23 October 2002. " + $"I think i have been ?outed. Isn't? it?"; try { var splitSentences = new SingleRegExpRule(@"(?<=[.!?])\s+(?=[A-Z])", RuleType.RegExpSplit, "Split sentences"); var filterQuestions = new SingleRegExpRule(@"[?]$", RuleType.RegExpMatches, "Filter quesions"); var filterSentencesWithDate = new MultipleRegExpRules(new List <string> { @"\d{1,2}[/-]\d{1,2}[/-]\d{2,4}", @"(?:\d{1,2} )?(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)[a-z]* (?:\d{1,2}, )?\d{4}" }, RuleType.RegExpMatches, RulesConnectionType.Union, "Filter dates"); var initData = new ParserResult(data, null); var result = initData.SplitByRegExp(splitSentences).FilterByRegExp(filterQuestions).FilterByRegExp(filterSentencesWithDate); } catch (Exception e) { Console.WriteLine(e); } //var filterSentencesWithDate1 = new Rule(@"\d{1,2}[/-]\d{1,2}[/-]\d{2,4}", // RuleType.RegExpMatches, 2, null, "Filter date (format 1)"); //var filterSentencesWithDate2 = new Rule(@"(?:\d{1,2} )?(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)[a-z]* (?:\d{1,2}, )?\d{4}", // RuleType.RegExpMatches, 2, null, "Filter date (format 2)"); //split Console.WriteLine("SPLITTED INTO SENTENCES"); var split_senteces = Regex.Split(data, @"(?<=[.!?])\s+(?=[A-Z])"); //var split_senteces = Regex.Matches(data, @"(?<=[.!?])\s+(?=[A-Z])"); Console.WriteLine("Count: {0}", split_senteces.Length); for (int i = 0; i < split_senteces.Length; i++) { Console.WriteLine("#{0}: {1}", i + 1, split_senteces[i]); } //filter by condition Console.WriteLine("QUESTIONS"); var questions = split_senteces.Where(sentence => Regex.Match(sentence, @"[?]$").Success); foreach (var sentence in questions) { Console.WriteLine(sentence); } //filter by condition Console.WriteLine("QUESTIONS WITH DATES"); //var datesReg1 = @"\d{1,2}[/-]\d{1,2}[/-]\d{2,4}"; //var datesReg2 = @"(?:\d{1,2} )?(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)[a-z]* (?:\d{1,2}, )?\d{4}"; var dateRegs = new List <string>(); dateRegs.Add(@"\d{1,2}[/-]\d{1,2}[/-]\d{2,4}"); dateRegs.Add(@"(?:\d{1,2} )?(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)[a-z]* (?:\d{1,2}, )?\d{4}"); foreach (var sentence in questions) { foreach (var datesReg in dateRegs) { var matches = Regex.Matches(sentence, datesReg); if (matches.Count > 0) { Console.WriteLine("({0}) {1}", matches.Count, sentence); foreach (Match match in matches) { Console.Write("value: {0}, index: {1} \n", match.Value, match.Index); } } } } //var questionsWithDates = questions.Where(sentence => Regex.Match(sentence, datesReg1).Success || Regex.Match(sentence, datesReg2).Success); //foreach (var sentence in questionsWithDates) // Console.WriteLine(sentence); /* * //count * Console.WriteLine("FIND WORD 'I'"); * var foundWords = Regex.Matches(data, @"[.,?!]?\s+I\s+"); * foreach (Match res in foundWords) * { * Console.WriteLine("value: {0}, index: {1}", res.Value, res.Index); * } * * //calculate frequency of the word in text * var words = data.Split(' '); * float f = (float)foundWords.Count / words.Length * 100; * Console.WriteLine("FREQUENCY: {0:0.00}%", f); */ //take list of strings winth length>=1 //iterate over list and look for matches => list of matches with index, match itselt, its lenths //1. total dates, total sentences with dates, print these sentences ordered by frequency. /* * //list entries * Console.WriteLine("LIST ALL DATES"); * var datesReg1 = @"\d{1,2}[/-]\d{1,2}[/-]\d{2,4}"; * var datesReg2 = @"(?:\d{1,2} )?(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)[a-z]* (?:\d{1,2}, )?\d{4}"; * var datesRes1 = Regex.Matches(data, datesReg1); * var datesRes2 = Regex.Matches(data, datesReg2); * foreach(Match res in datesRes1) * Console.WriteLine("value: {0}, index: {1}, length: {2}", res.Value, res.Index, res.Length); * foreach (Match res in datesRes2) * Console.WriteLine("value: {0}, index: {1}, length: {2}", res.Value, res.Index, res.Length); */ var blocks = new List <RulesBlock>(); //blocks.Add(new RulesBlock(blocks.Count+1, )); }
protected ParserResult(ParserResult.Internal* native, bool isInternalImpl = false) { __Instance = new global::System.IntPtr(native); }
public void Invoking_RenderParsingErrorsText_returns_appropriate_formatted_text() { // Fixture setup var fakeResult = new ParserResult<NullInstance>( ParserResultType.Options, new NullInstance(), new Error[] { new BadFormatTokenError("badtoken"), new MissingValueOptionError(new NameInfo("x", "switch")), new UnknownOptionError("unknown"), new MissingRequiredOptionError(new NameInfo("", "missing")), new MutuallyExclusiveSetError(new NameInfo("z", "")), new SequenceOutOfRangeError(new NameInfo("s", "sequence")), new NoVerbSelectedError(), new BadVerbSelectedError("badverb"), new HelpRequestedError(), // should be ignored new HelpVerbRequestedError(null, null, false), // should be ignored }, Maybe.Nothing<IEnumerable<Type>>()); Func<Error, string> fakeRenderer = err => { switch (err.Tag) { case ErrorType.BadFormatTokenError: return "ERR " + ((BadFormatTokenError)err).Token; case ErrorType.MissingValueOptionError: return "ERR " + ((MissingValueOptionError)err).NameInfo.NameText; case ErrorType.UnknownOptionError: return "ERR " + ((UnknownOptionError)err).Token; case ErrorType.MissingRequiredOptionError: return "ERR " + ((MissingRequiredOptionError)err).NameInfo.NameText; case ErrorType.MutuallyExclusiveSetError: return "ERR " + ((MutuallyExclusiveSetError)err).NameInfo.NameText; case ErrorType.SequenceOutOfRangeError: return "ERR " + ((SequenceOutOfRangeError)err).NameInfo.NameText; case ErrorType.NoVerbSelectedError: return "ERR no-verb-selected"; case ErrorType.BadVerbSelectedError: return "ERR " + ((BadVerbSelectedError)err).Token; default: throw new InvalidOperationException(); } }; // Exercize system var errorsText = HelpText.RenderParsingErrorsText(fakeResult, fakeRenderer, 2); // Verify outcome var lines = errorsText.ToNotEmptyLines(); Assert.Equal(" ERR badtoken", lines[0]); Assert.Equal(" ERR x, switch", lines[1]); Assert.Equal(" ERR unknown", lines[2]); Assert.Equal(" ERR missing", lines[3]); Assert.Equal(" ERR z", lines[4]); Assert.Equal(" ERR s, sequence", lines[5]); Assert.Equal(" ERR no-verb-selected", lines[6]); Assert.Equal(" ERR badverb", lines[7]); // Teardown }
void OnFileParsed(string file, ParserResult result) { switch (result.Kind) { case ParserResultKind.Success: Diagnostics.Message("Parsed '{0}'", file); break; case ParserResultKind.Error: Diagnostics.Error("Error parsing '{0}'", file); break; case ParserResultKind.FileNotFound: Diagnostics.Error("File '{0}' was not found", file); break; } for (uint i = 0; i < result.DiagnosticsCount; ++i) { var diag = result.getDiagnostics(i); if (Options.IgnoreParseWarnings && diag.Level == ParserDiagnosticLevel.Warning) continue; if (diag.Level == ParserDiagnosticLevel.Note) continue; Diagnostics.Message("{0}({1},{2}): {3}: {4}", diag.FileName, diag.LineNumber, diag.ColumnNumber, diag.Level.ToString().ToLower(), diag.Message); } }
public void Invoke_AutoBuild_for_Options_returns_appropriate_formatted_text() { // Fixture setup var fakeResult = new ParserResult<FakeOptions>( ParserResultType.Options, new FakeOptions(), new Error[] { new BadFormatTokenError("badtoken"), new SequenceOutOfRangeError(new NameInfo("i", "")) }, Maybe.Nothing<IEnumerable<Type>>()); // Exercize system var helpText = HelpText.AutoBuild(fakeResult); // Verify outcome var lines = helpText.ToString().ToNotEmptyLines().TrimStringArray(); Assert.True(lines[0].StartsWith("CommandLine", StringComparison.Ordinal)); Assert.True(lines[1].StartsWith("Copyright (c)", StringComparison.Ordinal)); Assert.Equal("ERROR(S):", lines[2]); Assert.Equal("Token 'badtoken' is not recognized.", lines[3]); Assert.Equal("A sequence option 'i' is defined with few items than required.", lines[4]); Assert.Equal("--stringvalue Define a string value here.", lines[5]); Assert.Equal("-i Define a int sequence here.", lines[6]); Assert.Equal("-x Define a boolean or switch value here.", lines[7]); Assert.Equal("--help Display this help screen.", lines[8]); // Teardown }
internal ParserResult(ParserResult.Internal native) : this(__CopyValue(native)) { }
public void Invoke_AutoBuild_for_Verbs_with_specific_verb_returns_appropriate_formatted_text() { // Fixture setup var fakeResult = new ParserResult<object>( ParserResultType.Verbs, new NullInstance(), new Error[] { new HelpVerbRequestedError("commit", typeof(CommitOptions), true) }, Maybe.Nothing<IEnumerable<Type>>()); // Exercize system var helpText = HelpText.AutoBuild(fakeResult); // Verify outcome var lines = helpText.ToString().ToNotEmptyLines().TrimStringArray(); Assert.True(lines[0].StartsWith("CommandLine", StringComparison.Ordinal)); Assert.True(lines[1].StartsWith("Copyright (c)", StringComparison.Ordinal)); Assert.Equal("-p, --patch Use the interactive patch selection interface to chose which", lines[2]); Assert.Equal("changes to commit.", lines[3]); Assert.Equal("--amend Used to amend the tip of the current branch.", lines[4]); Assert.Equal("--help Display this help screen.", lines[5]); // Teardown }
/// <summary> /// Main entry point to the sample. /// </summary> public static async Task Main(string[] args) { // Parse and validate parameters CommandLineOptions options = null; ParserResult <CommandLineOptions> result = Parser.Default.ParseArguments <CommandLineOptions>(args) .WithParsed(parsedOptions => { options = parsedOptions; }) .WithNotParsed(errors => { Environment.Exit(1); }); // Instantiate the client #region Snippet:IotHubServiceClientInitializeWithIotHubSasCredential // Create an IotHubSasCredential type to use sas tokens to authenticate against your IoT Hub instance. // The default lifespan of the sas token is 30 minutes, and it is set to be renewed when at 15% or less of its lifespan. var credential = new IotHubSasCredential(options.IotHubSharedAccessPolicy, options.IotHubSharedAccessKey); IotHubServiceClient hubClient = new IotHubServiceClient(options.Endpoint, credential); #endregion Snippet:IotHubServiceClientInitializeWithIotHubSasCredential // Run the samples var deviceIdentityLifecycleSamples = new DeviceIdentityLifecycleSample(hubClient); await deviceIdentityLifecycleSamples.RunSampleAsync(); var moduleIdentityLifecycleSamples = new ModuleIdentityLifecycleSample(hubClient); await moduleIdentityLifecycleSamples.RunSampleAsync(); var bulkDeviceIdentityLifecycleSamples = new BulkDeviceIdentityLifecycleSample(hubClient); await bulkDeviceIdentityLifecycleSamples.RunSampleAsync(); var bulkModuledentityLifecycleSamples = new BulkModuleIdentityLifecycleSample(hubClient); await bulkModuledentityLifecycleSamples.RunSampleAsync(); var querySamples = new QueryTwinSample(hubClient); await querySamples.RunSampleAsync(); var statisticsSample = new StatisticsSample(hubClient); await statisticsSample.RunSampleAsync(); var configurationsSample = new ConfigurationSample(hubClient); await configurationsSample.RunSampleAsync(); // Get SAS token to 'jobs' container in the storage account. Uri containerSasUri = await GetSasUriAsync(options.StorageAccountConnectionString, "jobs").ConfigureAwait(false); var jobsSample = new JobsSample(hubClient, containerSasUri); await jobsSample.RunSampleAsync(); // Run samples that require the device sample to be running. if (options.IsDeviceSampleRunning == true) { // This sample requires the device sample to be running so that it can connect to the device. var methodInvocationSamples = new MethodInvocationSamples(hubClient); await methodInvocationSamples.RunSampleAsync(); } }
public void Invoke_AutoBuild_for_Verbs_with_unknown_verb_returns_appropriate_formatted_text() { // Fixture setup var verbTypes = Enumerable.Empty<Type>().Concat( new[] { typeof(AddOptions), typeof(CommitOptions), typeof(CloneOptions) }); var fakeResult = new ParserResult<object>( ParserResultType.Verbs, new NullInstance(), new Error[] { new HelpVerbRequestedError(null, null, false) }, Maybe.Just(verbTypes)); // Exercize system var helpText = HelpText.AutoBuild(fakeResult); // Verify outcome var lines = helpText.ToString().ToNotEmptyLines().TrimStringArray(); Assert.True(lines[0].StartsWith("CommandLine", StringComparison.Ordinal)); Assert.True(lines[1].StartsWith("Copyright (c)", StringComparison.Ordinal)); Assert.Equal("add Add file contents to the index.", lines[2]); Assert.Equal("commit Record changes to the repository.", lines[3]); Assert.Equal("clone Clone a repository into a new directory.", lines[4]); Assert.Equal("help Display more information on a specific command.", lines[5]); // Teardown }
void OnFileParsed(string file, ParserResult result) { OnFileParsed(new[] { file }, result); }
/// <inheritdoc /> protected override void OnStartup(StartupEventArgs e) { // Setup JsonConvert.DefaultSettings = () => JsonHelper.CreateSettings(); string basePath = Assembly.GetExecutingAssembly().GetDirectoryPath(); bool consoleCreated = false; if (e.Args.Length > 0) { ConsoleHelper.AttachConsole(out consoleCreated); if (ConsoleHelper.HasConsole) { ConsoleHelper.Show(); } else { Logger.LogError("Could not create Writer window."); Shutdown(); return; } } // Configuration Logger.LogInformation("Loading configuration."); IConfiguration configuration = IConfigurationBuilderHelper.CreateConfiguration(basePath) .AddConfigurationFiles(basePath, EnvironmentHelper.GetEnvironmentName()) .AddEnvironmentVariables() .AddUserSecrets() .AddArguments(e.Args) .Build(); Parser parser = null; StartupArguments args; try { // Command line Logger.LogInformation("Processing command line."); parser = new Parser(settings => { settings.CaseSensitive = false; settings.CaseInsensitiveEnumValues = true; }); ParserResult <StartupArguments> result = parser.ParseArguments <StartupArguments>(e.Args); if (result.Tag == ParserResultType.NotParsed) { Logger.LogError(StartupArguments.GetUsage(result)); Shutdown(); return; } args = ((Parsed <StartupArguments>)result).Value; } catch (Exception ex) { Logger.LogError(ex.CollectMessages()); Shutdown(); return; } finally { // in case an error occurred and the parser was not disposed ObjectHelper.Dispose(ref parser); } // Logging Logger.LogInformation("Configuring logging."); if (configuration.GetValue <bool>("Logging:Enabled") && args.LogLevel < LogLevel.None) { LoggerConfiguration loggerConfiguration = new(); loggerConfiguration.ReadFrom.Configuration(configuration); loggerConfiguration.MinimumLevel.Is(args.LogLevel switch { LogLevel.Trace => LogEventLevel.Verbose, LogLevel.Debug => LogEventLevel.Debug, LogLevel.Information => LogEventLevel.Information, LogLevel.Warning => LogEventLevel.Warning, LogLevel.Error => LogEventLevel.Error, _ => LogEventLevel.Fatal });
static async Task Main(string[] args) { Stopwatch watch = new Stopwatch(); watch.Start(); // Parse arguments passed Parser parser = new Parser(with => { with.CaseInsensitiveEnumValues = true; with.CaseSensitive = false; with.HelpWriter = null; }); ParserResult <Options> parserResult = parser.ParseArguments <Options>(args); parserResult.WithParsed <Options>(o => { Options.Instance = o; }) .WithNotParsed(errs => DisplayHelp(parserResult, errs)); Options options = Options.Instance; try { smithy = new Smithy(); if (options.Quiet) { Log.Logger = new LoggerConfiguration() .MinimumLevel.Error() .WriteTo.Console() .CreateLogger(); } else { Log.Logger = new LoggerConfiguration() .MinimumLevel.Information() .WriteTo.Console() .CreateLogger(); } await DoCrawl(smithy); Uri uri = new Uri(smithy.Url); string safeUri = uri.Authority; safeUri = safeUri.Replace('.', '_'); if (string.IsNullOrEmpty(smithy.Output)) { smithy.Output = "wordlist_" + safeUri + DateTime.Now.ToString("_HH-mm-ss") + ".txt"; if (smithy.Output.Length > 250) { smithy.Output = "wordlist_" + DateTime.Now.ToString("M-dd-yyyy_HH-mm-ss") + ".txt"; } } Console.WriteLine($"\n[+] Crawl finished, writing to file: {smithy.Output}\n"); using (StreamWriter outfile = new StreamWriter(smithy.Output)) { foreach (var word in wordlist) { await outfile.WriteLineAsync(word); } } watch.Stop(); Console.WriteLine("Execution time: " + watch.ElapsedMilliseconds / 1000 + " Seconds"); } catch (Exception e) { Console.WriteLine(e); } }
private static int Main(string[] args) { #if DEBUG if (args.LastOrDefault() == "--debug") { WriteArgs(args.Take(args.Length - 1).ToArray(), Verbosity.Quiet); return(ExitCodes.NotSuccess); } #endif Parser parser = null; try { parser = CreateParser(ignoreUnknownArguments: true); if (args == null || args.Length == 0) { HelpCommand.WriteCommandsHelp(); return(ExitCodes.Success); } bool?success = null; ParserResult <BaseCommandLineOptions> defaultResult = parser .ParseArguments <BaseCommandLineOptions>(args) .WithParsed(options => { if (!options.Help) { return; } string commandName = args?.FirstOrDefault(); Command command = (commandName != null) ? CommandLoader.LoadCommand(typeof(Program).Assembly, commandName) : null; if (!ParseVerbosityAndOutput(options)) { success = false; return; } WriteArgs(args, Verbosity.Diagnostic); if (command != null) { HelpCommand.WriteCommandHelp(command); } else { HelpCommand.WriteCommandsHelp(); } success = true; }); if (success == false) { return(ExitCodes.Error); } if (success == true) { return(ExitCodes.Success); } parser = CreateParser(); ParserResult <object> parserResult = parser.ParseArguments( args, new Type[] { typeof(AnalyzeCommandLineOptions), typeof(FixCommandLineOptions), typeof(FormatCommandLineOptions), typeof(GenerateDocCommandLineOptions), typeof(GenerateDocRootCommandLineOptions), typeof(HelpCommandLineOptions), typeof(ListSymbolsCommandLineOptions), typeof(LogicalLinesOfCodeCommandLineOptions), typeof(MigrateCommandLineOptions), typeof(PhysicalLinesOfCodeCommandLineOptions), typeof(RenameSymbolCommandLineOptions), typeof(SpellcheckCommandLineOptions), #if DEBUG typeof(AnalyzeAssemblyCommandLineOptions), typeof(FindSymbolsCommandLineOptions), typeof(GenerateSourceReferencesCommandLineOptions), typeof(ListVisualStudioCommandLineOptions), typeof(ListReferencesCommandLineOptions), typeof(SlnListCommandLineOptions), #endif }); parserResult.WithNotParsed(e => { if (e.Any(f => f.Tag == ErrorType.VersionRequestedError)) { Console.WriteLine(typeof(Program).GetTypeInfo().Assembly.GetName().Version); success = false; return; } var helpText = new HelpText(SentenceBuilder.Create(), HelpCommand.GetHeadingText()); helpText = HelpText.DefaultParsingErrorsHandler(parserResult, helpText); VerbAttribute verbAttribute = parserResult.TypeInfo.Current.GetCustomAttribute <VerbAttribute>(); if (verbAttribute != null) { helpText.AddPreOptionsText(Environment.NewLine + HelpCommand.GetFooterText(verbAttribute.Name)); } Console.Error.WriteLine(helpText); success = false; }); if (success == true) { return(ExitCodes.Success); } if (success == false) { return(ExitCodes.Error); } parserResult.WithParsed <AbstractCommandLineOptions>( options => { if (ParseVerbosityAndOutput(options)) { WriteArgs(args, Verbosity.Diagnostic); } else { success = false; } }); if (success == false) { return(ExitCodes.Error); } return(parserResult.MapResult( (MSBuildCommandLineOptions options) => { switch (options) { case AnalyzeCommandLineOptions analyzeCommandLineOptions: return AnalyzeAsync(analyzeCommandLineOptions).Result; case FixCommandLineOptions fixCommandLineOptions: return FixAsync(fixCommandLineOptions).Result; case FormatCommandLineOptions formatCommandLineOptions: return FormatAsync(formatCommandLineOptions).Result; case GenerateDocCommandLineOptions generateDocCommandLineOptions: return GenerateDocAsync(generateDocCommandLineOptions).Result; case GenerateDocRootCommandLineOptions generateDocRootCommandLineOptions: return GenerateDocRootAsync(generateDocRootCommandLineOptions).Result; case ListSymbolsCommandLineOptions listSymbolsCommandLineOptions: return ListSymbolsAsync(listSymbolsCommandLineOptions).Result; case LogicalLinesOfCodeCommandLineOptions logicalLinesOfCodeCommandLineOptions: return LogicalLinesOrCodeAsync(logicalLinesOfCodeCommandLineOptions).Result; case PhysicalLinesOfCodeCommandLineOptions physicalLinesOfCodeCommandLineOptions: return PhysicalLinesOfCodeAsync(physicalLinesOfCodeCommandLineOptions).Result; case RenameSymbolCommandLineOptions renameSymbolCommandLineOptions: return RenameSymbolAsync(renameSymbolCommandLineOptions).Result; case SpellcheckCommandLineOptions spellcheckCommandLineOptions: return SpellcheckAsync(spellcheckCommandLineOptions).Result; #if DEBUG case FindSymbolsCommandLineOptions findSymbolsCommandLineOptions: return FindSymbolsAsync(findSymbolsCommandLineOptions).Result; case GenerateSourceReferencesCommandLineOptions generateSourceReferencesCommandLineOptions: return GenerateSourceReferencesAsync(generateSourceReferencesCommandLineOptions).Result; case ListReferencesCommandLineOptions listReferencesCommandLineOptions: return ListReferencesAsync(listReferencesCommandLineOptions).Result; case SlnListCommandLineOptions slnListCommandLineOptions: return SlnListAsync(slnListCommandLineOptions).Result; #endif default: throw new InvalidOperationException(); } }, (AbstractCommandLineOptions options) => { switch (options) { case HelpCommandLineOptions helpCommandLineOptions: return Help(helpCommandLineOptions); case MigrateCommandLineOptions migrateCommandLineOptions: return Migrate(migrateCommandLineOptions); #if DEBUG case AnalyzeAssemblyCommandLineOptions analyzeAssemblyCommandLineOptions: return AnalyzeAssembly(analyzeAssemblyCommandLineOptions); case ListVisualStudioCommandLineOptions listVisualStudioCommandLineOptions: return ListVisualStudio(listVisualStudioCommandLineOptions); #endif default: throw new InvalidOperationException(); } }, _ => ExitCodes.Error)); } catch (Exception ex) when(ex is AggregateException || ex is FileNotFoundException || ex is InvalidOperationException) { WriteError(ex); } finally { parser?.Dispose(); Out?.Dispose(); Out = null; } return(ExitCodes.Error); }
protected bool FunctionalTest() { ParserResult root = ((T)Activator.CreateInstance(typeof(T), "HTTP/1.1 404 Not found\r\nHeader1: data1\r\nErrorHeader\r\nHeader2: data2\r\nHeader3: data3\r\nHeader4: data4\r\nErrorHeaderFinal\r\n\r\nHello! This is the body!")) .Until("version", " ") .Until("code", " ", converter: s => int.Parse(s)) .Until("message", "\r\n") .RepeatUntil("headers", "\r\n\r\n", b => b .Or(bb => bb .Until("name", ":", validator: s => !s.Contains("\r\n")) .Until("value", "\r\n", converter: s => s.Trim()), bb => bb .Until("error", "\r\n"), bb => bb .ToEnd("final", converter: bs => bs.GetString()))) .ToEnd("body", converter: bs => bs.GetString()) .Close(); if (IsVerbose) { Console.WriteLine(":: FunctionalTest"); Console.WriteLine("Version :"); Console.WriteLine(root["version"]); Console.WriteLine("Code :"); Console.WriteLine(root["code"]); Console.WriteLine("Message :"); Console.WriteLine(root["message"]); Console.WriteLine("Headers :"); foreach (var e in root.GetList("headers")) { if (e.ContainsKey("final")) { Console.WriteLine(e["final"] + "|"); } else if (e.ContainsKey("error")) { Console.WriteLine(e["error"] + "|"); } else { Console.WriteLine(e["name"] + " = " + e["value"] + "|"); } } Console.WriteLine("Body :"); Console.WriteLine(root["body"]); } if (!root["version"].Equals("HTTP/1.1")) { return(false); } if (!root["code"].Equals(404)) { return(false); } if (!root["message"].Equals("Not found")) { return(false); } if (!root["headers.<0>.name"].Equals("Header1")) { return(false); } if (!root["headers.<0>.value"].Equals("data1")) { return(false); } if (!root["headers.<1>.error"].Equals("ErrorHeader")) { return(false); } if (!root["headers.<2>.name"].Equals("Header2")) { return(false); } if (!root["headers.<2>.value"].Equals("data2")) { return(false); } if (!root["headers.<3>.name"].Equals("Header3")) { return(false); } if (!root["headers.<3>.value"].Equals("data3")) { return(false); } if (!root["headers.<4>.name"].Equals("Header4")) { return(false); } if (!root["headers.<4>.value"].Equals("data4")) { return(false); } if (!root["headers.<5>.final"].Equals("ErrorHeaderFinal")) { return(false); } if (!root["body"].Equals("Hello! This is the body!")) { return(false); } return(true); }
/// <summary> /// Entry point method for CLI. /// </summary> public static int Main(string[] args) { // Interactive mode: commands separated by line if (args.Length == 0) { while (true) { Console.Write("$ "); args = Console.ReadLine()?.Split(' '); ParserResult <object> parseInteractiveResult = Parser.Default.ParseArguments <RunCommand, ExtractCommand, TestCommand, GenerateCommand, HeadersCommand, CsvConvertCommand, ExitCommand, WriteSchemaCommand>(args); if (parseInteractiveResult is Parsed <object> parsedInteractive) { switch (parsedInteractive.Value) { case RunCommand runOptions: runOptions.Execute(); break; case ExtractCommand extractOptions: extractOptions.Execute(); break; case TestCommand testOptions: testOptions.Execute(); break; case GenerateCommand generateOptions: generateOptions.Execute(); break; case HeadersCommand headersOptions: headersOptions.Execute(); break; case CsvConvertCommand convertOptions: convertOptions.Execute(); break; case WriteSchemaCommand writeSchemaOptions: writeSchemaOptions.Execute(); break; case ExitCommand _: return(0); default: return(-1); } } // Exit and show help if command is not recognized else if (parseInteractiveResult is NotParsed <object> ) { return(-1); } } } // Single command mode ParserResult <object> parseResult = Parser.Default.ParseArguments <RunCommand, ExtractCommand, TestCommand, GenerateCommand, HeadersCommand, CsvConvertCommand, WriteSchemaCommand, ExitCommand>(args); if (parseResult is Parsed <object> parsed) { switch (parsed.Value) { case RunCommand runOptions: runOptions.Execute(); break; case ExtractCommand extractOptions: extractOptions.Execute(); break; case TestCommand testOptions: testOptions.Execute(); break; case GenerateCommand generateOptions: generateOptions.Execute(); break; case HeadersCommand headersOptions: headersOptions.Execute(); break; case CsvConvertCommand convertOptions: convertOptions.Execute(); break; case WriteSchemaCommand writeSchemaOptions: writeSchemaOptions.Execute(); break; case ExitCommand _: return(0); } } return(-1); }
/// <summary> /// Creates a default instance of the <see cref="CommandLine.Text.HelpText"/> class, /// automatically handling verbs or options scenario. /// </summary> /// <param name='parserResult'>The <see cref="CommandLine.ParserResult{T}"/> containing the instance that collected command line arguments parsed with <see cref="CommandLine.Parser"/> class.</param> /// <param name="maxDisplayWidth">The maximum width of the display.</param> /// <returns> /// An instance of <see cref="CommandLine.Text.HelpText"/> class. /// </returns> /// <remarks>This feature is meant to be invoked automatically by the parser, setting the HelpWriter property /// of <see cref="CommandLine.ParserSettings"/>.</remarks> public static HelpText AutoBuild <T>(ParserResult <T> parserResult, int maxDisplayWidth = DefaultMaximumLength) { return(AutoBuild <T>(parserResult, h => h, maxDisplayWidth)); }
/// <summary> /// Initializes a new instance of the <see cref="SummaryResult" /> class. /// </summary> /// <param name="parserResult">The parser result.</param> public SummaryResult(ParserResult parserResult) : this(parserResult.Assemblies, parserResult.ParserName, parserResult.SupportsBranchCoverage, parserResult.SourceDirectories) { }
/// <summary> /// Creates a new instance of the <see cref="CommandLine.Text.HelpText"/> class using common defaults. /// </summary> /// <returns> /// An instance of <see cref="CommandLine.Text.HelpText"/> class. /// </returns> /// <param name='parserResult'>The <see cref="CommandLine.ParserResult{T}"/> containing the instance that collected command line arguments parsed with <see cref="CommandLine.Parser"/> class.</param> /// <param name='onError'>A delegate used to customize the text block of reporting parsing errors text block.</param> /// <param name='onExample'>A delegate used to customize <see cref="CommandLine.Text.Example"/> model used to render text block of usage examples.</param> /// <param name="verbsIndex">If true the output style is consistent with verb commands (no dashes), otherwise it outputs options.</param> /// <param name="maxDisplayWidth">The maximum width of the display.</param> /// <remarks>The parameter <paramref name="verbsIndex"/> is not ontly a metter of formatting, it controls whether to handle verbs or options.</remarks> public static HelpText AutoBuild <T>( ParserResult <T> parserResult, Func <HelpText, HelpText> onError, Func <Example, Example> onExample, bool verbsIndex = false, int maxDisplayWidth = DefaultMaximumLength) { var auto = new HelpText { Heading = HeadingInfo.Empty, Copyright = CopyrightInfo.Empty, AdditionalNewLineAfterOption = true, AddDashesToOption = !verbsIndex, MaximumDisplayWidth = maxDisplayWidth }; try { auto.Heading = HeadingInfo.Default; auto.Copyright = CopyrightInfo.Default; } catch (Exception) { auto = onError(auto); } var errors = Enumerable.Empty <Error>(); if (onError != null && parserResult.Tag == ParserResultType.NotParsed) { errors = ((NotParsed <T>)parserResult).Errors; if (errors.OnlyMeaningfulOnes().Any()) { auto = onError(auto); } } ReflectionHelper.GetAttribute <AssemblyLicenseAttribute>() .Do(license => license.AddToHelpText(auto, true)); var usageAttr = ReflectionHelper.GetAttribute <AssemblyUsageAttribute>(); var usageLines = HelpText.RenderUsageTextAsLines(parserResult, onExample).ToMaybe(); if (usageAttr.IsJust() || usageLines.IsJust()) { var heading = auto.SentenceBuilder.UsageHeadingText(); if (heading.Length > 0) { auto.AddPreOptionsLine(heading); } } usageAttr.Do( usage => usage.AddToHelpText(auto, true)); usageLines.Do( lines => auto.AddPreOptionsLines(lines)); if ((verbsIndex && parserResult.TypeInfo.Choices.Any()) || errors.Any(e => e.Tag == ErrorType.NoVerbSelectedError)) { auto.AddDashesToOption = false; auto.AddVerbs(parserResult.TypeInfo.Choices.ToArray()); } else { auto.AddOptions(parserResult); } return(auto); }
protected abstract void Handle([NotNull] TContext context, [NotNull] ParserResult result);
public virtual void Calculate(DateTime t1, DateTime t2) { var t1a = t1; var t2a = t2; Logger.OnLogEvent += Logger_OnLogEvent; var seriesBeforeCalc = this.Clone(); //if( this.TimeInterval == TimeSeries.TimeInterval.Irregular) t2a = t2.AddDays(1); // we may need midnight value in the next day. if (this.TimeInterval == TimeSeries.TimeInterval.Daily) { // daily_wrdo_pu needs AdjustStartingDate t1a = this.AdjustStartingDateFromProperties(t1, t2a); // DO DO??? needed?? } Exception error = new Exception(); if (Expression != null && Expression.Trim() != "") { string tmpExpression = Expression; Logger.WriteLine("begin Calculate()"); Expression = ExpressionPreProcessor(); ParserResult result = null; try { result = Parser.Evaluate(this.Expression, t1a, t2a, this.TimeInterval); } catch (Exception e) { Console.WriteLine(e.Message); Logger.WriteLine(e.Message, "ui"); Messages.Add(e.Message); error = e; result = null; } if (result != null && (result.IsDouble || result.IsInteger)) { // constant expression, need to convert to a Series. Series constant = new Series(); constant.TimeInterval = this.TimeInterval; constant = Math.FillMissingWithZero(constant, t1, t2); if (result.IsDouble) { constant = Math.Add(constant, result.Double); } else { constant = Math.Add(constant, result.Integer); } result = new ParserResult(constant); } if (result != null && result.IsSeries) { result.Series.Trim(t1, t2); //var s = result.Series; //result.Series = Math.Subset(s, t1, t2); // trim extra data used for calculations Logger.WriteLine("Calculation result has " + result.Series.Count + " rows"); this.TimeInterval = result.Series.TimeInterval; string tableName = this.Table.TableName; this.Table = result.Series.Table; this.Table.TableName = tableName; if (m_db != null) { // Logger.WriteLine("Setting Flags"); m_db.Quality.SetFlags(this); } this.Table.AcceptChanges();// prevents error releated to Deleted rows from Trim() above. foreach (DataRow row in this.Table.Rows) { row.SetAdded(); // so database will insert these rows. } if (m_db != null) // database is not required for calculations. { //bool canSave = m_db.Server.HasSavePrivilge(this.Table.TableName); // if(canSave) m_db.SaveTimeSeriesTable(this.ID, this, DatabaseSaveOptions.UpdateExisting); Expression = tmpExpression; if (seriesBeforeCalc.TimeInterval != this.TimeInterval || seriesBeforeCalc.Units != this.Units) { Logger.WriteLine("Warning Units or interval has changed."); //if(canSave) m_db.SaveProperties(this); // time interval, units, are dependent on calculation. } } } else { Clear(); Console.WriteLine(error.Message); Logger.WriteLine(error.Message); } Logger.WriteLine("Calculate() completed"); Logger.OnLogEvent -= Logger_OnLogEvent; } }
public CommandLineParsingException(ParserResult <object> parserResult) { ParserResult = parserResult; }
static async Task <int> Main(string[] args) { Log.Logger = new LoggerConfiguration() .WriteTo.Console() .CreateLogger(); ParserResult <CommandlineArgs> argsResult = Parser.Default.ParseArguments <CommandlineArgs>(args); if (argsResult is NotParsed <CommandlineArgs> ) { Log.Logger.Error("Unable to parse arguments, be sure to include the path to the 'repos.json' file"); return(1); } CommandlineArgs parsedArgs = ((Parsed <CommandlineArgs>)argsResult).Value; if (!File.Exists(parsedArgs.RepositoryJson)) { Log.Logger.Error($"Unable to locate {parsedArgs.RepositoryJson}"); return(2); } RepositoryRoot configRoot = JsonConvert.DeserializeObject <RepositoryRoot>(await File.ReadAllTextAsync(parsedArgs.RepositoryJson)); IHost host = new HostBuilder() .ConfigureLogging(loggingBuilder => { loggingBuilder.AddSerilog(Log.Logger); }) .ConfigureServices(services => { if (!string.IsNullOrEmpty(parsedArgs.ProxyUrl)) { services.AddSingleton <IWebProxy>(_ => new WebProxy(parsedArgs.ProxyUrl)); } services.AddSingleton <IGitHubClient>(provider => { IWebProxy proxy = provider.GetService <IWebProxy>(); SimpleJsonSerializer jsonSerializer = new SimpleJsonSerializer(); return(new GitHubClient(new Connection(new ProductHeaderValue(ClientName), new Uri(parsedArgs.GithubApi), new InMemoryCredentialStore(new Credentials(parsedArgs.GithubToken)), new HttpClientAdapter( () => new HttpClientHandler { Proxy = proxy }), jsonSerializer))); }); services .AddSingleton(parsedArgs) .AddSingleton(configRoot) .AddSingleton(x => new GhStandardFileSetFactory(x.GetRequiredService <RepositoryRoot>(), parsedArgs.RepositoryJson)) .AddSingleton <GhStandardContentApplier>(); }) .Build(); GhStandardFileSetFactory fileSetFactory = host.Services.GetRequiredService <GhStandardFileSetFactory>(); GhStandardContentApplier applier = host.Services.GetRequiredService <GhStandardContentApplier>(); IEnumerable <KeyValuePair <string, JObject> > repos; if (!string.IsNullOrEmpty(parsedArgs.Repository) && configRoot.Repositories.TryGetValue(parsedArgs.Repository, out var singleRepo)) { repos = new[] { KeyValuePair.Create(parsedArgs.Repository, singleRepo) }; } else if (!string.IsNullOrEmpty(parsedArgs.Repository)) { // Try looking for a partial match var match = configRoot.Repositories.Keys.FirstOrDefault(s => s.Split('/').Last().Equals(parsedArgs.Repository, StringComparison.OrdinalIgnoreCase)); if (match == null) { Log.Error("Unable to run for {Repository} alone", parsedArgs.Repository); return(3); } repos = new[] { KeyValuePair.Create(match, configRoot.Repositories[match]) }; } else { repos = configRoot.Repositories; } foreach ((string repository, JObject config) in repos) { GhStandardFileSet fileSet = fileSetFactory.GetFileSet(config); if (fileSet.Count == 0) { Log.Debug("Skipping {Repository}, no files to manage", repository); continue; } string[] repoParts = repository.Split('/'); string repoOrg = repoParts[0]; string repoName = repoParts[1]; Log.Information("Applying {Count} files to {Organization} / {Repository}", fileSet.Count, repoOrg, repoName); await applier.Apply(repoOrg, repoName, fileSet); } return(0); }
public IEnumerable <CodeSpecificException> InitializeCodeModel(CppCodeModel codeModel, IncludeManagerParameter parameter) { HashSet <string> parsedIncludes = new HashSet <string>(parameter.KnownIncludes); List <CodeSpecificException> codeSpecificExceptions = new List <CodeSpecificException>(); VirtualFile cacheFile = fileSystem.GetFile(IncludeFilePath.CleanPath().ResolvePathName(environmentService.PathNames)); includeCache.LoadCache(cacheFile); UpdateCache(); codeModel.IncludeDirectories = parameter.IncludeDirectories; codeModel.RegisterIncludeTypeFinder(s => FindIncludeType(s, parameter.IncludeDirectories)); this.codeModel = codeModel; return(codeSpecificExceptions); void UpdateCache() { log.LogVerbose("Start updating the include cache."); Stopwatch loadWatch = new Stopwatch(); loadWatch.Start(); using (IIncludeCacheTransaction cacheTransaction = includeCache.StartTransaction()) { Stopwatch checkWatch = new Stopwatch(); checkWatch.Start(); foreach (IncludeCacheEntry staleEntry in FindStaleAndOutdatedEntries().ToArray()) { cacheTransaction.DeleteEntry(staleEntry); } checkWatch.Stop(); log.LogVerbose($"Checked files in {checkWatch.ElapsedMilliseconds} ms."); AddOrUpdate(parameter.IncludeDefinitions, cacheTransaction); } loadWatch.Stop(); log.LogVerbose($"Finished updating the include cache in {loadWatch.ElapsedMilliseconds} ms."); IEnumerable <IncludeCacheEntry> FindStaleAndOutdatedEntries() { return(includeCache.Entries.Where(e => !fileSystem.FileExists(e.File) || fileSystem.GetLastWriteTime(e.File) != e.LastWriteTime)); } void AddOrUpdate(IEnumerable <IncludeDefinition> includes, IIncludeCacheTransaction cacheTransaction) { Stack <IncludeDefinition> unvisited = new Stack <IncludeDefinition>(includes); while (unvisited.Any()) { IncludeDefinition include = unvisited.Pop(); if (TryFindInclude(include, out IncludeFindResult findResult)) { IEnumerable <IncludeDefinition> childDefinitions; if (findResult.IsInCache) { VirtualFile cacheSourceFile = fileSystem.GetFile(findResult.IncludeCacheEntry.File); VirtualDirectory cacheBaseDirectory = fileSystem.GetDirectory(findResult.IncludeCacheEntry.BaseDirectory); parsedIncludes.Add(cacheSourceFile.GetRelativePath(cacheBaseDirectory)); childDefinitions = findResult.IncludeCacheEntry.Includes .Select(i => new IncludeDefinition(i, cacheSourceFile, cacheBaseDirectory)); } else { parsedIncludes.Add(findResult.IncludeFile.GetRelativePath(findResult.IncludeBaseDirectory)); childDefinitions = ProcessInclude(findResult.IncludeFile, findResult.IncludeBaseDirectory); } foreach (IncludeDefinition childDefinition in childDefinitions) { unvisited.Push(childDefinition); } } } IEnumerable <IncludeDefinition> ProcessInclude(VirtualFile findResultIncludeFile, VirtualDirectory findResultIncludeBaseDirectory) { ParserResult parserResult = fileParser.Parse(findResultIncludeFile); if (!parserResult.Success) { codeSpecificExceptions.AddRange(parserResult.Exceptions); cacheTransaction.AddEntry(new IncludeCacheEntry(findResultIncludeFile.FullName, false, findResultIncludeFile.LastWriteTime, findResultIncludeBaseDirectory.FullName, Enumerable.Empty <string>(), Enumerable.Empty <string>())); return(Enumerable.Empty <IncludeDefinition>()); } foreach (IType type in parserResult.Types.Keys) { codeModel.AddType(type, findResultIncludeFile, findResultIncludeBaseDirectory); } codeSpecificExceptions.AddRange(parserResult.Exceptions); cacheTransaction.AddEntry(new IncludeCacheEntry(findResultIncludeFile.FullName, true, findResultIncludeFile.LastWriteTime, findResultIncludeBaseDirectory.FullName, parserResult.Types.Keys.Select(t => t.FullName), parserResult.Includes)); return(parserResult.Includes.Select( i => new IncludeDefinition( i, findResultIncludeFile, findResultIncludeBaseDirectory))); } bool TryFindInclude(IncludeDefinition current, out IncludeFindResult result) { if (current.Include.Trim().StartsWith("<", StringComparison.Ordinal)) { //system includes in form <algorithms> are ignored result = null; return(false); } //Try parse relative to source if (current.DefinitionSourceFile.Parent.TryGetFileFromPath(current.Include, out VirtualFile file)) { if (parsedIncludes.Contains(file.GetRelativePath(current.DefinitionSourceBaseDirectory))) { result = null; return(false); } result = includeCache.TryGetCacheEntry(file.FullName, out IncludeCacheEntry cacheEntry) ? new IncludeFindResult(cacheEntry) : new IncludeFindResult(file, current.DefinitionSourceBaseDirectory); return(true); } //Parse relative to include path foreach (VirtualDirectory includeDirectory in parameter.IncludeDirectories.Values.Where(v => v != null)) { if (includeDirectory.TryGetFileFromPath(current.Include, out file)) { if (parsedIncludes.Contains(file.GetRelativePath(includeDirectory))) { result = null; return(false); } result = includeCache.TryGetCacheEntry(file.FullName, out IncludeCacheEntry cacheEntry) ? new IncludeFindResult(cacheEntry) : new IncludeFindResult(file, includeDirectory); return(true); } } log.LogWarning($"Could not find include {current.Include}. Possible types from these files will not be parsed."); result = null; return(false); } } } }
public bool AcceptLine (SubString ss) { Result = ParserResult.Continue; CurrentLine = ss; Partial_BeginLine (); var bs = ss.BaseString; var begin = ss.Begin; var end = ss.End; for (var iter = begin; iter < end; ++iter) { CurrentCharacter = bs[iter]; apply: if (Result != ParserResult.Continue) { break; } switch (State) { case ParserState.Error: switch (CurrentCharacter) { default: Partial_StateTransition__From_Error (); Partial_StateTransition__From_Error__To_Error (); Partial_StateTransition__To_Error (); break; } break; case ParserState.WrongTagError: switch (CurrentCharacter) { default: State = ParserState.Error; Partial_StateTransition__From_WrongTagError (); Partial_StateTransition__From_WrongTagError__To_Error (); Partial_StateTransition__To_Error (); break; } break; case ParserState.NonEmptyTagError: switch (CurrentCharacter) { default: State = ParserState.Error; Partial_StateTransition__From_NonEmptyTagError (); Partial_StateTransition__From_NonEmptyTagError__To_Error (); Partial_StateTransition__To_Error (); break; } break; case ParserState.PreProcessing: switch (CurrentCharacter) { case '!': State = ParserState.PreProcessorTag; Partial_StateTransition__From_PreProcessing (); Partial_StateTransition__From_PreProcessing__To_PreProcessorTag (); Partial_StateTransition__To_PreProcessorTag (); break; default: State = ParserState.Indention; Partial_StateTransition__From_PreProcessing (); Partial_StateTransition__From_PreProcessing__To_Indention (); Partial_StateTransition__To_Indention (); goto apply; break; } break; case ParserState.Indention: switch (CurrentCharacter) { case '\t': Partial_StateTransition__From_Indention (); Partial_StateTransition__From_Indention__To_Indention (); Partial_StateTransition__To_Indention (); break; default: Partial_StateChoice__From_Indention__Choose_TagExpected_NoContentTagExpected_ValueLine_Error (); switch (State) { case ParserState.TagExpected: Partial_StateTransition__From_Indention (); Partial_StateTransition__From_Indention__To_TagExpected (); Partial_StateTransition__To_TagExpected (); break; case ParserState.NoContentTagExpected: Partial_StateTransition__From_Indention (); Partial_StateTransition__From_Indention__To_NoContentTagExpected (); Partial_StateTransition__To_NoContentTagExpected (); break; case ParserState.ValueLine: Partial_StateTransition__From_Indention (); Partial_StateTransition__From_Indention__To_ValueLine (); Partial_StateTransition__To_ValueLine (); break; case ParserState.Error: Partial_StateTransition__From_Indention (); Partial_StateTransition__From_Indention__To_Error (); Partial_StateTransition__To_Error (); break; default: Result = ParserResult.Error; break; } goto apply; break; } break; case ParserState.TagExpected: switch (CurrentCharacter) { case '@': State = ParserState.ObjectTag; Partial_StateTransition__From_TagExpected (); Partial_StateTransition__From_TagExpected__To_ObjectTag (); Partial_StateTransition__To_ObjectTag (); break; case '=': State = ParserState.ValueTag; Partial_StateTransition__From_TagExpected (); Partial_StateTransition__From_TagExpected__To_ValueTag (); Partial_StateTransition__To_ValueTag (); break; case '#': State = ParserState.CommentTag; Partial_StateTransition__From_TagExpected (); Partial_StateTransition__From_TagExpected__To_CommentTag (); Partial_StateTransition__To_CommentTag (); break; case '\t': case ' ': State = ParserState.EmptyTag; Partial_StateTransition__From_TagExpected (); Partial_StateTransition__From_TagExpected__To_EmptyTag (); Partial_StateTransition__To_EmptyTag (); break; default: State = ParserState.WrongTagError; Partial_StateTransition__From_TagExpected (); Partial_StateTransition__From_TagExpected__To_WrongTagError (); Partial_StateTransition__To_WrongTagError (); break; } break; case ParserState.NoContentTagExpected: switch (CurrentCharacter) { case '#': State = ParserState.CommentTag; Partial_StateTransition__From_NoContentTagExpected (); Partial_StateTransition__From_NoContentTagExpected__To_CommentTag (); Partial_StateTransition__To_CommentTag (); break; case '\t': case ' ': State = ParserState.EmptyTag; Partial_StateTransition__From_NoContentTagExpected (); Partial_StateTransition__From_NoContentTagExpected__To_EmptyTag (); Partial_StateTransition__To_EmptyTag (); break; default: State = ParserState.WrongTagError; Partial_StateTransition__From_NoContentTagExpected (); Partial_StateTransition__From_NoContentTagExpected__To_WrongTagError (); Partial_StateTransition__To_WrongTagError (); break; } break; case ParserState.PreProcessorTag: switch (CurrentCharacter) { default: Partial_StateTransition__From_PreProcessorTag (); Partial_StateTransition__From_PreProcessorTag__To_PreProcessorTag (); Partial_StateTransition__To_PreProcessorTag (); break; } break; case ParserState.ObjectTag: switch (CurrentCharacter) { default: Partial_StateTransition__From_ObjectTag (); Partial_StateTransition__From_ObjectTag__To_ObjectTag (); Partial_StateTransition__To_ObjectTag (); break; } break; case ParserState.ValueTag: switch (CurrentCharacter) { default: Partial_StateTransition__From_ValueTag (); Partial_StateTransition__From_ValueTag__To_ValueTag (); Partial_StateTransition__To_ValueTag (); break; } break; case ParserState.EmptyTag: switch (CurrentCharacter) { case '\t': case ' ': Partial_StateTransition__From_EmptyTag (); Partial_StateTransition__From_EmptyTag__To_EmptyTag (); Partial_StateTransition__To_EmptyTag (); break; default: State = ParserState.NonEmptyTagError; Partial_StateTransition__From_EmptyTag (); Partial_StateTransition__From_EmptyTag__To_NonEmptyTagError (); Partial_StateTransition__To_NonEmptyTagError (); break; } break; case ParserState.CommentTag: switch (CurrentCharacter) { default: Partial_StateTransition__From_CommentTag (); Partial_StateTransition__From_CommentTag__To_CommentTag (); Partial_StateTransition__To_CommentTag (); break; } break; case ParserState.EndOfPreProcessorTag: switch (CurrentCharacter) { default: State = ParserState.PreProcessing; Partial_StateTransition__From_EndOfPreProcessorTag (); Partial_StateTransition__From_EndOfPreProcessorTag__To_PreProcessing (); Partial_StateTransition__To_PreProcessing (); goto apply; break; } break; case ParserState.EndOfObjectTag: switch (CurrentCharacter) { default: State = ParserState.Indention; Partial_StateTransition__From_EndOfObjectTag (); Partial_StateTransition__From_EndOfObjectTag__To_Indention (); Partial_StateTransition__To_Indention (); goto apply; break; } break; case ParserState.EndOfEmptyTag: switch (CurrentCharacter) { default: State = ParserState.Indention; Partial_StateTransition__From_EndOfEmptyTag (); Partial_StateTransition__From_EndOfEmptyTag__To_Indention (); Partial_StateTransition__To_Indention (); goto apply; break; } break; case ParserState.EndOfValueTag: switch (CurrentCharacter) { default: State = ParserState.Indention; Partial_StateTransition__From_EndOfValueTag (); Partial_StateTransition__From_EndOfValueTag__To_Indention (); Partial_StateTransition__To_Indention (); goto apply; break; } break; case ParserState.EndOfCommentTag: switch (CurrentCharacter) { default: State = ParserState.Indention; Partial_StateTransition__From_EndOfCommentTag (); Partial_StateTransition__From_EndOfCommentTag__To_Indention (); Partial_StateTransition__To_Indention (); goto apply; break; } break; case ParserState.ValueLine: switch (CurrentCharacter) { default: Partial_StateTransition__From_ValueLine (); Partial_StateTransition__From_ValueLine__To_ValueLine (); Partial_StateTransition__To_ValueLine (); break; } break; case ParserState.EndOfValueLine: switch (CurrentCharacter) { default: State = ParserState.Indention; Partial_StateTransition__From_EndOfValueLine (); Partial_StateTransition__From_EndOfValueLine__To_Indention (); Partial_StateTransition__To_Indention (); goto apply; break; } break; default: Result = ParserResult.Error; break; } } if (Result == ParserResult.Error) { return false; } // EndOfLine CurrentCharacter = EndOfStream; { switch (State) { case ParserState.Indention: State = ParserState.EndOfEmptyTag; Partial_StateTransition__From_Indention (); Partial_StateTransition__From_Indention__To_EndOfEmptyTag (); Partial_StateTransition__To_EndOfEmptyTag (); break; case ParserState.TagExpected: State = ParserState.EndOfEmptyTag; Partial_StateTransition__From_TagExpected (); Partial_StateTransition__From_TagExpected__To_EndOfEmptyTag (); Partial_StateTransition__To_EndOfEmptyTag (); break; case ParserState.NoContentTagExpected: State = ParserState.EndOfEmptyTag; Partial_StateTransition__From_NoContentTagExpected (); Partial_StateTransition__From_NoContentTagExpected__To_EndOfEmptyTag (); Partial_StateTransition__To_EndOfEmptyTag (); break; case ParserState.PreProcessorTag: State = ParserState.EndOfPreProcessorTag; Partial_StateTransition__From_PreProcessorTag (); Partial_StateTransition__From_PreProcessorTag__To_EndOfPreProcessorTag (); Partial_StateTransition__To_EndOfPreProcessorTag (); break; case ParserState.ObjectTag: State = ParserState.EndOfObjectTag; Partial_StateTransition__From_ObjectTag (); Partial_StateTransition__From_ObjectTag__To_EndOfObjectTag (); Partial_StateTransition__To_EndOfObjectTag (); break; case ParserState.ValueTag: State = ParserState.EndOfValueTag; Partial_StateTransition__From_ValueTag (); Partial_StateTransition__From_ValueTag__To_EndOfValueTag (); Partial_StateTransition__To_EndOfValueTag (); break; case ParserState.EmptyTag: State = ParserState.EndOfEmptyTag; Partial_StateTransition__From_EmptyTag (); Partial_StateTransition__From_EmptyTag__To_EndOfEmptyTag (); Partial_StateTransition__To_EndOfEmptyTag (); break; case ParserState.CommentTag: State = ParserState.EndOfCommentTag; Partial_StateTransition__From_CommentTag (); Partial_StateTransition__From_CommentTag__To_EndOfCommentTag (); Partial_StateTransition__To_EndOfCommentTag (); break; case ParserState.ValueLine: State = ParserState.EndOfValueLine; Partial_StateTransition__From_ValueLine (); Partial_StateTransition__From_ValueLine__To_EndOfValueLine (); Partial_StateTransition__To_EndOfValueLine (); break; } } Partial_EndLine (); return Result != ParserResult.Error; }
public abstract void Register(ref ParserResult <object> parserResult);
public static ParserResult __CreateInstance(ParserResult.Internal native) { return new ParserResult(native); }
static void Main(string[] args) { int threads = 1; int timeout = 30; string fileName = ""; FileType fileType = FileType.HostFile; bool appendPorts = false; bool prependHttps = false; List <string> hostList = null; //Parse command line arguments ParserResult <Options> argResults = Parser.Default.ParseArguments <Options>(args); ParserResult <Options> res = argResults.WithParsed <Options>(o => { appendPorts = o.AppendPorts; prependHttps = o.PrependHTTPS; threads = o.NumThreads; timeout = o.Timeout; if (o.FileName == "") { System.Console.WriteLine("Please provide the name of a host file or a Nessus file"); System.Environment.Exit(1); } fileName = o.FileName; //Automatically determine file type try { System.IO.StreamReader file = new System.IO.StreamReader(fileName); string line = file.ReadLine(); if (line != null) { if (line.Contains("xml version")) { fileType = FileType.Nessus; } else { fileType = FileType.HostFile; } } file.Close(); } catch { System.Console.WriteLine(string.Format("Could not open file: {0}", fileName)); System.Environment.Exit(1); } }); //This takes care of if the --help option was used if (argResults.Tag == CommandLine.ParserResultType.NotParsed) { System.Environment.Exit(1); } //Get hosts if (fileType == FileType.HostFile) { FileParser fParser = new FileParser(); hostList = fParser.Parse(fileName, prependHttps, appendPorts); } else if (fileType == FileType.Nessus) { NessusParser nParser = new NessusParser(); hostList = nParser.Parse(fileName); } if (hostList == null) { System.Environment.Exit(1); } foreach (string host in hostList) { System.Console.WriteLine(host); } //Create a new WebShot object for screenshotting. WebShot webshot = new WebShot(threads, timeout); //Some examples of screenshotting for now... //webshot.ScreenShot("https://google.com"); //webshot.ScreenShot("https://www.blackhillsinfosec.com"); //webshot.ScreenShot("http://www.reddit.com"); }
private ParserResult(ParserResult.Internal native) : this(__CopyValue(native)) { __ownsNativeInstance = true; NativeToManagedMap[__Instance] = this; }
static void Main(string[] args) { ParserResult <Arguments> parseResult = Parser.Default.ParseArguments <Arguments>(args); if (parseResult.Errors.Any()) { return; } Arguments arguments = parseResult.Value; // Создаем коллекцию всех существительных. CyrNounCollection nouns = new CyrNounCollection(); // Создаем коллекцию всех прилагательных. CyrAdjectiveCollection adjectives = new CyrAdjectiveCollection(); // Создаем фразу с использование созданных коллекций. CyrPhrase phrase = new CyrPhrase(nouns, adjectives); InjectionAnalyzer analyzer = new InjectionAnalyzer(); HashSet <string> defTypes = new HashSet <string>(arguments.DefsTypes.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries)); HashSet <string> ignoredInjections = File.Exists(arguments.IgnoreFile) ? new HashSet <string>(File.ReadAllLines(arguments.IgnoreFile)) : new HashSet <string>(); HashSet <string> pluralizedLabels = File.Exists(arguments.Output) ? new HashSet <string>(File.ReadAllLines(arguments.Output).Select(line => new string(line.TakeWhile(c => c != ';').ToArray()))) : new HashSet <string>(); Injection[] allLabels = analyzer .ReadInjections(arguments.DefsPath) .Where(inj => defTypes.Contains(inj.DefType)) .Where(inj => GetLastPart(inj).ToLowerInvariant().Contains("label")) .Distinct(new InjectionTypeTranslationComparer()) .Where(inj => !ignoredInjections.Contains(FormInjectionLine(inj)) && !pluralizedLabels.Contains(inj.Translation)) .ToArray(); Console.WriteLine($"Check plural forms for {allLabels.Length} labels."); List <Option> history = new List <Option>(); string prevDefType = ""; PluralPair pluralPair = null; for (int labelIndex = 0; labelIndex < allLabels.Length;) { Injection injection = allLabels[labelIndex]; string label = injection.Translation; Console.WriteLine(); Console.WriteLine($"{labelIndex + 1}/{allLabels.Length} {injection.DefType} <{injection.DefPath}> \"{label}\":"); if (pluralPair == null) { pluralPair = PluralizeIgnoreSuffix(phrase, label, " (", " из ", " для ", " с ", " в "); } if (pluralPair == null) { Console.WriteLine($" Failed to pluralize"); } else { WritePluralization(pluralPair); } Console.Write("<Enter> - accept; <Space> - edit; <Backspace> - back; <Delete> - ignore"); ConsoleKey key = Console.ReadKey().Key; Console.WriteLine(); switch (key) { case ConsoleKey.Escape: return; case ConsoleKey.Spacebar: if (pluralPair == null) { pluralPair = new PluralPair(label, label); } pluralPair = EditPluralization(pluralPair); if (injection.DefType != prevDefType) { FileUtil.PushLine(arguments.Output, string.Empty); FileUtil.PushLine(arguments.Output, "// " + injection.DefType); } FileUtil.PushLine(arguments.Output, ToLine(pluralPair)); pluralPair = null; history.Add(Option.Accept); labelIndex++; break; case ConsoleKey.Enter: if (pluralPair != null) { if (injection.DefType != prevDefType) { FileUtil.PushLine(arguments.Output, string.Empty); FileUtil.PushLine(arguments.Output, "// " + injection.DefType); } FileUtil.PushLine(arguments.Output, ToLine(pluralPair)); pluralPair = null; history.Add(Option.Accept); labelIndex++; } break; case ConsoleKey.Delete: FileUtil.PushLine(arguments.IgnoreFile, FormInjectionLine(injection)); pluralPair = null; history.Add(Option.Ignore); labelIndex++; break; case ConsoleKey.Backspace: Option prevOption = history[labelIndex - 1]; history.RemoveAt(labelIndex - 1); labelIndex--; if (prevOption == Option.Accept) { string prevDeclinationLine = FileUtil.PopLine(arguments.Output); pluralPair = FromLine(prevDeclinationLine); } else if (prevOption == Option.Ignore) { FileUtil.PopLine(arguments.IgnoreFile); pluralPair = null; } break; default: break; } prevDefType = injection.DefType; } }
public static ParserResult __CreateInstance(ParserResult.__Internal native, bool skipVTables = false) { return new ParserResult(native, skipVTables); }
static void Main(string[] args) { AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException; LConfig = new LoggerConfiguration() .Enrich.FromLogContext() .MinimumLevel.Debug() .WriteTo.Console(outputTemplate: "{Timestamp:HH:mm:ss}<{ThreadId:d2}> [{Level:u3}] {Message}{NewLine}{Exception}"); L = Log.Logger = LConfig.CreateLogger(); Type[] BindOptionTypes = Assembly.GetExecutingAssembly().GetTypes().Where(t => t == typeof(Options) || t.IsSubclassOf(typeof(Options))).ToArray(); MethodInfo parseArgumentsMethod = typeof(ParserExtensions).GetMethods().Where(m => m.IsGenericMethod && m.Name == "ParseArguments" && m.GetGenericArguments().Count() == BindOptionTypes.Count()).First(); Parser p = new Parser(); ParserResult <object> result = (ParserResult <object>)parseArgumentsMethod.MakeGenericMethod(BindOptionTypes).Invoke(p, new object[] { p, args }); result.WithNotParsed((IEnumerable <Error> errors) => { HelpText help = GetAutoBuiltHelpText(result); help.MaximumDisplayWidth = Console.WindowWidth; help.Copyright = string.Empty; help.Heading = new HeadingInfo("Sylvester Bindings CLI", Version.ToString(3)); help.AddPreOptionsLine(string.Empty); if (errors.Any(e => e.Tag == ErrorType.VersionRequestedError)) { Log.Information(help); Exit(ExitResult.SUCCESS); } else if (errors.Any(e => e.Tag == ErrorType.HelpVerbRequestedError)) { HelpVerbRequestedError error = (HelpVerbRequestedError)errors.First(e => e.Tag == ErrorType.HelpVerbRequestedError); if (error.Type != null) { help.AddVerbs(error.Type); } else { help.AddVerbs(BindOptionTypes); } Log.Information(help); Exit(ExitResult.SUCCESS); } else if (errors.Any(e => e.Tag == ErrorType.HelpRequestedError)) { help.AddOptions(result); L.Information(help); Exit(ExitResult.SUCCESS); } else if (errors.Any(e => e.Tag == ErrorType.NoVerbSelectedError)) { help.AddVerbs(BindOptionTypes); help.AddPreOptionsLine("No library selected. Select a library or verb from the options below:"); L.Information(help); Exit(ExitResult.INVALID_OPTIONS); } else if (errors.Any(e => e.Tag == ErrorType.MissingRequiredOptionError)) { MissingRequiredOptionError error = (MissingRequiredOptionError)errors.First(e => e is MissingRequiredOptionError); help.AddOptions(result); help.AddPreOptionsLine($"A required option or value is missing: {error.NameInfo.NameText} The options and values for this benchmark category are: "); L.Information(help); Exit(ExitResult.INVALID_OPTIONS); } else if (errors.Any(e => e.Tag == ErrorType.MissingValueOptionError)) { MissingValueOptionError error = (MissingValueOptionError)errors.First(e => e.Tag == ErrorType.MissingValueOptionError); help.AddOptions(result); help.AddPreOptionsLine($"A required option or value is missing. The options and values for this category are: "); L.Information(help); Exit(ExitResult.INVALID_OPTIONS); } else if (errors.Any(e => e.Tag == ErrorType.UnknownOptionError)) { UnknownOptionError error = (UnknownOptionError)errors.First(e => e.Tag == ErrorType.UnknownOptionError); help.AddOptions(result); help.AddPreOptionsLine($"Unknown option: {error.Token}."); L.Information(help); Exit(ExitResult.INVALID_OPTIONS); } else { help.AddPreOptionsLine($"An error occurred parsing the program options: {string.Join(" ", errors.Select(e => e.Tag.ToString()).ToArray())}"); help.AddVerbs(BindOptionTypes); L.Information(help); Exit(ExitResult.INVALID_OPTIONS); } }) .WithParsed <Options>(o => { if (string.IsNullOrEmpty(o.ModuleName)) { Log.Error($"You must select a module to create bindings for. Use the --help option to get the list of available modules."); Exit(ExitResult.INVALID_OPTIONS); } if (!string.IsNullOrEmpty(o.Root) && !Directory.Exists(o.Root)) { Log.Error($"The library root directory specified {o.Root} does not exist."); Exit(ExitResult.INVALID_OPTIONS); } else if (!string.IsNullOrEmpty(o.Root)) { ProgramOptions.Add("RootDirectory", new DirectoryInfo(o.Root)); } foreach (PropertyInfo prop in o.GetType().GetProperties()) { ProgramOptions.Add(prop.Name, prop.GetValue(o)); } }) .WithParsed <PlaidMLOptions>(o => { if (!File.Exists(Path.Combine(AssemblyDirectory.FullName, "plaidml", "base.h"))) { L.Error($"The PlaidML header file {Path.Combine(AssemblyDirectory.FullName, "plaidml", "base.h")} was not found."); Exit(ExitResult.FILE_MISSING); } else if (!File.Exists(Path.Combine(AssemblyDirectory.FullName, "plaidml", "plaidml.h"))) { L.Error($"The PlaidML header file {Path.Combine(AssemblyDirectory.FullName, "plaidml", "plaidml.h")} was not found."); Exit(ExitResult.FILE_MISSING); } ProgramLibrary = new PlaidML(ProgramOptions); ConsoleDriver.Run(ProgramLibrary); if (ProgramLibrary.CleanAndFixup()) { Exit(ExitResult.SUCCESS); } else { Exit(ExitResult.ERROR_DURING_CLEANUP); } }) .WithParsed <TensorFlowOptions>(o => { if (!File.Exists(Path.Combine(AssemblyDirectory.FullName, "tf", "c_api.h"))) { L.Error($"The TensorFlow header file {Path.Combine(AssemblyDirectory.FullName, "tf", "c_api.h")} was not found."); Exit(ExitResult.FILE_MISSING); } ProgramLibrary = new TensorFlow(ProgramOptions); ConsoleDriver.Run(ProgramLibrary); if (ProgramLibrary.CleanAndFixup()) { Exit(ExitResult.SUCCESS); } else { Exit(ExitResult.ERROR_DURING_CLEANUP); } }); }
private ParserResult(ParserResult.__Internal native, bool skipVTables = false) : this(__CopyValue(native), skipVTables) { __ownsNativeInstance = true; NativeToManagedMap[__Instance] = this; }
/// <summary> /// Méthode de parsing d'une expression. /// </summary> /// <param name="expression">Expression à parser.</param> /// <param name="year">Année.</param> /// <returns>Un <see cref="ParserResult"/> correspondant.</returns> public override ParserResult Parse(string expression, int year) { var result = new ParserResult(); var regex = new Regex(Pattern.ToString()); var match = regex.Match(expression); if (match.Success) { var calendar = Parser.GetCalendar(match.Groups["Calendar"].Value); if (!(calendar is System.Globalization.GregorianCalendar)) { year = calendar.GetYear(DateTime.Today.Of(year)); } var date = new DateTime(year, int.Parse(match.Groups["month"].Value), int.Parse(match.Groups["day"].Value), calendar); if (match.Groups["year"].Value.IsNotNullOrEmpty()) { date = date.SetYear(int.Parse(match.Groups["year"].Value)); } if (match.Groups["StartHours"].Value.IsNotNullOrEmpty() && match.Groups["StartMinutes"].Value.IsNotNullOrEmpty()) { date = date.SetTime(int.Parse(match.Groups["StartHours"].Value), int.Parse(match.Groups["StartMinutes"].Value)); } if (match.Groups["Expected"].Value.IsNotNullOrEmpty()) { if (date.DayOfWeek.ToString().ToUpper() == match.Groups["Expected"].Value) { if (match.Groups["NewHours"].Value.IsNotNullOrEmpty() && match.Groups["NewMinutes"].Value.IsNotNullOrEmpty()) { date = date.SetTime(int.Parse(match.Groups["NewHours"].Value), int.Parse(match.Groups["NewMinutes"].Value)); } } } if (match.Groups["RepeatEndYear"].Value.IsNotNullOrEmpty()) { if (date.Year > int.Parse(match.Groups["RepeatEndYear"].Value)) { return(result); } } var isYearTypeOk = false; if (match.Groups["YearType"].Value.IsNotNullOrEmpty()) { switch ((YearType)Enum.Parse(typeof(YearType), match.Groups["YearType"].Value, true)) { case Even: if (date.Year % 2 == 0) { isYearTypeOk = true; } break; case Odd: if (date.Year % 2 != 0) { isYearTypeOk = true; } break; case Leap: if (DateTime.IsLeapYear(date.Year)) { isYearTypeOk = true; } break; case NonLeap: if (!DateTime.IsLeapYear(date.Year)) { isYearTypeOk = true; } break; default: isYearTypeOk = false; break; } } else { isYearTypeOk = true; } var isYearRecursOk = false; if (match.Groups["RepeatYear"].Value.IsNotNullOrEmpty() && match.Groups["RepeatStartYear"].Value.IsNotNullOrEmpty()) { var numberYear = int.Parse(match.Groups["RepeatYear"].Value); var startYear = int.Parse(match.Groups["RepeatStartYear"].Value); if (date.Year >= startYear && ((date.Year - startYear) % numberYear) == 0) { isYearRecursOk = true; } } else { isYearRecursOk = true; } if (isYearTypeOk && isYearRecursOk && (match.Groups["year"].Value.IsNotNullOrEmpty() ? date.Year == year : true)) { result.DatesToAdd.Add(date); if (match.Groups["DurationDays"].Value.IsNotNullOrEmpty()) { var number = int.Parse(match.Groups["DurationDays"].Value); for (var i = 1; i < number; i++) { result.DatesToAdd.Add(i.Days().After(date.Midnight())); } } } } return(result); }
void OnSourceFileParsed(SourceFile file, ParserResult result) { OnFileParsed(file.Path, result); }
internal ParserResult(ParserResult.Internal* native) : this(new global::System.IntPtr(native)) { }