internal override int ParseMethod(ParsingSession session, out object result) { object identifier, value; int returnValue = -1; result = null; // dick if (identifierParser.Run (session, out identifier) > -1) { // = if (Couple(session, ref identifier)) { // "butt"; session.DeepenContext(identifier as String); int iresult = InnerParser.Run (session, out value); if (iresult > 0) { session.ContextRegister(value); session.SurfaceContext(identifier as String); result = new Tuple<string, object> ((string)identifier, value); returnValue = 1; } else { session.SurfaceContext(identifier as String); } } } return returnValue; }
internal override int ParseMethod(ParsingSession session, out object result) { int resultCount; object identObj; string identifier; object valueObj; string value; result = null; resultCount = base.ParseMethod (session, out dummy); if (hashtagEater.ParseMethod (session, out dummy) > 0) { if (identifierEater.ParseMethod (session, out identObj) < 0) throw new ParsingException (session, identifierEater, session.Trail); if (base.ParseMethod (session, out dummy) < 1) throw new ParsingException (session, this, session.Trail); if (valueEater.ParseMethod (session, out valueObj) < 0) throw new ParsingException (session, valueEater, session.Trail); identifier = (string)identObj; value = (string)valueObj; if (identifier.ToLower () == "include") resultCount = IncludeFileIntoSession (value, session); if (identifier.ToLower() == "pwd") { Directory.SetCurrentDirectory(value); } } return resultCount; }
internal override int ParseMethod(ParsingSession session, out object result) { var headDefinition = Parse<Settings>.Using (HeadParser, session); var baseDefinitions = Parse<List<Settings>>.Using (PredefParser, session); var chainedDefinition = Parse<Settings>.Using (ChainParser, session); var bodyDefinition = Parse<Settings>.Using (BodyParser, session); var successorDefinition = Parse<Settings>.Using (SuccessorParser, session); if (chainedDefinition != null) { headDefinition [Syntax.ChainSubstitution] = chainedDefinition; } if (successorDefinition != null) { headDefinition [Syntax.SuccessorSubstitution] = successorDefinition; } baseDefinitions.Add (headDefinition); baseDefinitions.Add (bodyDefinition); var cleanDefinitions = baseDefinitions.FindAll (delegate(Settings obj) { return obj != null; }); cleanDefinitions.Reverse (); result = Settings.FromMerge (cleanDefinitions.ToArray()); return 1; }
public ParsingException(ParsingSession session, Parser parser, string after = "(not given)", string before = "(not given)") : base(string.Format( "Expected {0} at line {1}, offset {2}, col {3}, after {4}, before {5}", parser.ToString(), session.CurrentLine.ToString(), session.Offset.ToString(), session.CurrentColumn.ToString(), after, before)) { }
protected override bool Couple(ParsingSession session, ref object identifier) { if (!base.Couple (session, ref identifier)) { foreach (CharacterParser parser in couplerParsers) { if (parser.Run (session) < 0) { return false; } } identifier = string.Concat (identifier, this.CouplerSuffix); } return true; }
internal override int ParseMethod(ParsingSession session, out object result) { int filenameLength = -1; result = null; if (opener.ParseMethod (session, out dummy) > 0) { if (this.innerParser.ParseMethod (session, out result) > 0) { if (closer.ParseMethod (session, out dummy) > 0) { filenameLength = ((string)result).Length; } } } return filenameLength; }
protected override int ParseListBody(ParsingSession session, ref List<object> target) { object defaultValue; bool thereIsMore = true; if (valueParser.ParseMethod (session, out defaultValue) > -1) { target.Add (new Tuple<string, object> ("default", defaultValue)); thereIsMore = (coupler.Run(session) > 0); } if (thereIsMore) { return base.ParseListBody (session, ref target); } else { return closer.Run(session); } }
/// <summary> /// Includes a file into a session. /// </summary> /// <returns> /// The included file length /// </returns> /// <param name='fileName'> /// File name. /// </param> /// <param name='session'> /// Session. /// </param> int IncludeFileIntoSession(string fileName, ParsingSession session) { if (File.Exists (fileName)) { FileInfo info = new FileInfo(fileName); string fileData; using(StreamReader reader = new StreamReader(info.OpenRead())) { fileData = reader.ReadToEnd(); } session.Data = session.Data.Insert ( session.Offset, fileData); return fileData.Length; } else { throw new Exception ("During parsing, file not found: " + fileName); } }
protected virtual bool Couple(ParsingSession session, ref object identifier) { return coupler.Run (session) > -1; }
/// <summary> /// Reads all contents from a file for usage in a ParsingSession, and uses /// and alternative parser for whitespace regions (i.e. #operations) /// </summary> /// <returns>The file.</returns> /// <param name="file">File.</param> /// <param name="whitespaceParser">Whitespace parser.</param> public static ParsingSession FromFile(string file, Parser whitespaceParser, bool profilingEnabled = false) { ParsingSession result = new ParsingSession (File.ReadAllText (file), whitespaceParser, profilingEnabled); result.SourceFile = new FileInfo (file); result.WorkingDirectory = result.SourceFile.Directory.FullName; return result; }
/// <summary> /// Run the specified session and result. /// </summary> /// <param name='session'> /// Session. /// </param> /// <param name='result'> /// Result. /// </param> public int Run(ParsingSession session, out object result) { result = null; // this is never good if (session.Offset >= session.Data.Length) return -1; if ((session.whitespaceParser != null) && (this != session.whitespaceParser)) session.whitespaceParser.Run (session, out dummy); if (session.ProfilingEnabled) return ProfiledParseMethod (session, out result); else return ParseMethod (session, out result); }
/// <summary> /// Run the Parser using the specified Session. /// </summary> /// <param name='session'> /// Session to use. /// </param> public int Run(ParsingSession session) { return Run(session, out dummy); }
internal int ProfiledParseMethod(ParsingSession session, out object result) { int resultCode = 0; object aresult = null; session.ParsingProfiler.CheckIn (GetProfileName(), delegate() { resultCode = ParseMethod(session, out aresult); }); result = aresult; return resultCode; }
/// <summary> /// Method which parses data from session into resulting object /// </summary> /// <returns> /// Success value, greater than -1 when succesful. /// </returns> /// <param name='session'> /// ParsingSession to get data from. /// </param> /// <param name='result'> /// Result of Parse Action, if any. /// </param> internal abstract int ParseMethod(ParsingSession session, out object result);