void MakePart(IWord word, ISourceLine location, PartOfSpeech part, string description, Func <OldParserWord, Action <Context, ISourceLine, byte> > getSetter, ref byte next, bool onlyNumberedInV3 = false) { var result = (OldParserWord)word; if ((result.PartOfSpeech & part) != 0) { return; } byte value; if (!onlyNumberedInV3 || ctx.ZEnvironment.ZVersion == 3) { if (next == 0) { throw new InterpreterError( InterpreterMessages.Too_Many_0_Only_1_Allowed_In_This_Vocab_Format, description, 255); } value = next--; } else { value = 0; } getSetter(result)(ctx, location, value); }
/// <exception cref="InvalidOperationException">Too many adjectives.</exception> public void MakeAdjective(IWord word, ISourceLine location) { var nw = (NewParserWord)word; if (!nw.HasClass(adjClass)) { ZilFix value; if (ctx.ZEnvironment.ZVersion < 4) { if (nextAdjective == 0) { throw new InterpreterError( InterpreterMessages.Too_Many_0_Only_1_Allowed_In_This_Vocab_Format, "adjectives", 255); } value = new ZilFix(nextAdjective--); } else { value = null; } NewAddWord( nw.Atom, ctx.GetStdAtom(StdAtom.TADJ), value, ZilFix.Zero); } }
public Syntax(ISourceLine src, [NotNull] IWord verb, int numObjects, [CanBeNull] IWord prep1, [CanBeNull] IWord prep2, byte options1, byte options2, [CanBeNull] ZilAtom findFlag1, [CanBeNull] ZilAtom findFlag2, [NotNull] ZilAtom action, [CanBeNull] ZilAtom preaction, [NotNull] ZilAtom actionName, [ItemNotNull][CanBeNull] IEnumerable <ZilAtom> synonyms = null) { SourceLine = src; Verb = verb; NumObjects = numObjects; Preposition1 = prep1; Preposition2 = prep2; Options1 = options1; Options2 = options2; FindFlag1 = findFlag1; FindFlag2 = findFlag2; Action = action; Preaction = preaction; ActionName = actionName; if (synonyms == null) { Synonyms = EmptySynonyms; } else { Synonyms = new List <ZilAtom>(synonyms).AsReadOnly(); } }
public LocalBindingRecord(LocalBindingType type, [NotNull] ISourceLine definition, [NotNull] string boundName, [NotNull] ILocalBuilder storage) { Type = type; Definition = definition; LocalBuilder = storage; BoundName = boundName; }
public void SetObject(ISourceLine location) { if ((PartOfSpeech & PartOfSpeech.Object) == 0) { // there is no PartOfSpeech.ObjectFirst, so don't change the First flags PartOfSpeech |= PartOfSpeech.Object; speechValues[PartOfSpeech.Object] = 1; definitions[PartOfSpeech.Object] = location; } }
public void MakeObject(IWord word, ISourceLine location) { var nw = (NewParserWord)word; if (!nw.HasClass(objectClass)) { NewAddWord( nw.Atom, ctx.GetStdAtom(StdAtom.TOBJECT), null, ZilFix.Zero); } }
public void MakeSyntaxPreposition(IWord word, ISourceLine location) { var nw = (NewParserWord)word; if (!nw.HasClass(particleClass)) { NewAddWord( nw.Atom, ctx.GetStdAtom(StdAtom.PARTICLE), null, ZilFix.Zero); } }
public void MakePreposition(IWord word, ISourceLine location) { var nw = (NewParserWord)word; if (!nw.HasClass(prepClass)) { NewAddWord( nw.Atom, ctx.GetStdAtom(StdAtom.TPREP), null, ZilFix.Zero); } }
public void MakeBuzzword(IWord word, ISourceLine location) { var nw = (NewParserWord)word; if (!nw.HasClass(buzzClass)) // always true since this translates to 0 { NewAddWord( nw.Atom, ctx.GetStdAtom(StdAtom.TBUZZ), null, ZilFix.Zero); } }
public Diagnostic([NotNull] ISourceLine location, Severity severity, [NotNull] string codePrefix, int codeNumber, [NotNull] string messageFormat, [ItemNotNull][CanBeNull] object[] messageArgs, [CanBeNull] string stackTrace, [ItemNotNull][CanBeNull] IReadOnlyList <Diagnostic> subDiagnostics) { Location = location; Severity = severity; CodePrefix = codePrefix; CodeNumber = codeNumber; MessageFormat = messageFormat; MessageArgs = messageArgs ?? NoArguments; StackTrace = stackTrace; SubDiagnostics = subDiagnostics ?? NoDiagnostics; }
public void SetDirection([NotNull] Context ctx, ISourceLine location, byte value) { if ((PartOfSpeech & PartOfSpeech.Direction) == 0) { if (ShouldSetFirst(ctx)) { PartOfSpeech |= PartOfSpeech.DirectionFirst; } PartOfSpeech |= PartOfSpeech.Direction; speechValues[PartOfSpeech.Direction] = value; definitions[PartOfSpeech.Direction] = location; } }
public void SetAdjective([NotNull] Context ctx, ISourceLine location, byte value) { if ((PartOfSpeech & PartOfSpeech.Adjective) == 0) { if (ctx.ZEnvironment.ZVersion < 4 && ShouldSetFirst(ctx)) { PartOfSpeech |= PartOfSpeech.AdjectiveFirst; } PartOfSpeech |= PartOfSpeech.Adjective; speechValues[PartOfSpeech.Adjective] = value; definitions[PartOfSpeech.Adjective] = location; } }
public void SetBuzzword([NotNull] Context ctx, ISourceLine location, byte value) { if ((PartOfSpeech & PartOfSpeech.Buzzword) == 0) { // buzzword value comes before everything but preposition, except in CompactVocab if (!IsCompactVocab(ctx)) { PartOfSpeech &= ~PartOfSpeech.FirstMask; } PartOfSpeech |= PartOfSpeech.Buzzword; speechValues[PartOfSpeech.Buzzword] = value; definitions[PartOfSpeech.Buzzword] = location; } }
public void MakeDirection(IWord word, ISourceLine location) { var result = (OldParserWord)word; if ((result.PartOfSpeech & PartOfSpeech.Direction) == 0) { var index = ctx.ZEnvironment.Directions.IndexOf(result.Atom); if (index == -1) { throw new ArgumentException("Not a direction"); } result.SetDirection(ctx, location, (byte)index); } }
public Diagnostic GetDiagnostic(ISourceLine location, int code, object[] messageArgs, string stackTrace, Diagnostic[] subDiagnostics) { var attr = messages[code]; return(new Diagnostic( location, attr.Severity, prefix, code, attr.Format, messageArgs, stackTrace, subDiagnostics)); }
public void SetPreposition([NotNull] Context ctx, ISourceLine location, byte value) { if ((PartOfSpeech & PartOfSpeech.Preposition) == 0) { // preposition value is always first, except in CompactVocab if (!IsCompactVocab(ctx)) { PartOfSpeech &= ~PartOfSpeech.FirstMask; } PartOfSpeech |= PartOfSpeech.Preposition; speechValues[PartOfSpeech.Preposition] = value; definitions[PartOfSpeech.Preposition] = location; } }
public ILocalBuilder PushInnerLocal([NotNull] IRoutineBuilder rb, [NotNull] ZilAtom atom, LocalBindingType reason, ISourceLine src) { if (Locals.TryGetValue(atom, out var prev)) { // save the old binding if (OuterLocals.TryGetValue(atom, out var stk) == false) { stk = new Stack <LocalBindingRecord>(); OuterLocals.Add(atom, stk); } stk.Push(prev); } ILocalBuilder result; if (SpareLocals.Count > 0) { // reuse a spare variable result = SpareLocals.Pop(); } else { // allocate a new variable with a unique name var tempName = MakeUniqueVariableName(atom); try { result = rb.DefineLocal(tempName.Text); } catch (InvalidOperationException) { throw new CompilerError(CompilerMessages.Expression_Needs_Temporary_Variables_Not_Allowed_Here); } TempLocalNames.Add(tempName); } var lbr = new LocalBindingRecord(reason, src, atom.Text, result); Locals[atom] = lbr; AllLocalBindingRecords.Add(lbr); return(result); }
/// <exception cref="ArgumentException"><paramref name="word"/> is not a direction.</exception> public void MakeDirection(IWord word, ISourceLine location) { var nw = (NewParserWord)word; if (!nw.HasClass(dirClass)) { var index = ctx.ZEnvironment.Directions.IndexOf(nw.Atom); if (index == -1) { throw new ArgumentException("Not a direction"); } NewAddWord( nw.Atom, ctx.GetStdAtom(StdAtom.TDIR), ZilAtom.Parse("P?" + nw.Atom.Text, ctx), ZilFix.Zero); } }
public void MakeVerb(IWord word, ISourceLine location) { var nw = (NewParserWord)word; if (!nw.HasClass(verbClass)) { var form = new ZilForm(new ZilObject[] { ctx.GetStdAtom(StdAtom.MAKE_VERB_DATA) }); var verbData = (ZilObject)form.Eval(ctx); nw.VerbStuff = verbData; ctx.PutProp(verbData, ctx.GetStdAtom(StdAtom.VERB_STUFF_ID), nw.Inner); NewAddWord( nw.Atom, ctx.GetStdAtom(StdAtom.TVERB), verbData, ZilFix.Zero); } }
public static Syntax Parse(ISourceLine src, [NotNull] IEnumerable <ZilObject> definition, [NotNull] Context ctx) { int numObjects = 0; ZilAtom verb = null, prep1 = null, prep2 = null; ZilAtom action = null, preaction = null, actionName = null; ZilList bits1 = null, find1 = null, bits2 = null, find2 = null, syns = null; bool rightSide = false; int rhsCount = 0; // main parsing foreach (var obj in definition) { if (verb == null) { if (obj is ZilAtom atom && atom.StdAtom != StdAtom.Eq) { verb = atom; } else { throw new InterpreterError(InterpreterMessages.Missing_0_In_1, "verb", "syntax definition"); } }
/// <exception cref="InterpreterError">Syntax error.</exception> public static IEnumerable <ZilObject> Parse([NotNull] Context ctx, ISourceLine src, [NotNull] IEnumerable <char> chars, params ZilObject[] templateParams) { var parser = new Parser(ctx, src, templateParams); foreach (var po in parser.Parse(chars)) { if (po.IsIgnorable) { continue; } switch (po.Type) { case ParserOutputType.Object: yield return(po.Object); break; case ParserOutputType.EndOfInput: yield break; case ParserOutputType.SyntaxError: throw new InterpreterError( src ?? new FileSourceLine(ctx.CurrentFile.Path, parser.Line), InterpreterMessages.Syntax_Error_0, po.Exception.Message); case ParserOutputType.Terminator: throw new InterpreterError( src ?? new FileSourceLine(ctx.CurrentFile.Path, parser.Line), InterpreterMessages.Syntax_Error_0, "misplaced terminator"); default: throw new UnhandledCaseException("parser output type"); } } }
protected AssemblerError(ISourceLine node, string message) : base(message) { Node = node; }
public Token(ISourceLine line) { Line = line; }
void ReportErrorAndSkipExpr(ISourceLine node, [NotNull] string message) { ReportError(node, message); SkipExpr(); }
void ReportErrorAndSkipExpr(ISourceLine node, [NotNull] string format, [NotNull] params object[] args) { ReportError(node, format, args); SkipExpr(); }
public static Diagnostic GetDiagnostic([NotNull] this IDiagnosticFactory fac, [NotNull] ISourceLine location, int code, object[] messageArgs, string stackTrace) { return(fac.GetDiagnostic(location, code, messageArgs, stackTrace, null)); }
public static ZilResult ToZilListResult([NotNull] this IEnumerable <ZilResult> inputs, ISourceLine sourceLine) { var array = inputs.Trim().ToArray(); if (array.Length > 0 && array[array.Length - 1].ShouldPass()) { return(array[array.Length - 1]); } return(new ZilList(array.Select(i => (ZilObject)i)) { SourceLine = sourceLine }); }
public Warning(ISourceLine node, string message) : base(node, message) { }
public FatalError(ISourceLine node, string message) : base(node, message) { }
public CompilerFatal(ISourceLine sourceLine, int code, [ItemNotNull] params object[] messageArgs) : base(MakeDiagnostic(sourceLine, code, messageArgs)) { }
public CompilerFatal(ISourceLine sourceLine, int code) : this(sourceLine, code, null) { }