private static void OperatorSerialise(SerialisationArgs args) { if (args.Peek().Token != ParseToken.OP) { return; } var opChar = Array.IndexOf(Dict.Operators, args.Peek().Text); if (opChar <= -1) { return; } if (args.Peek().Text == ".") { Log.Step("Serial: scope", args.Peek().Text); args.OutToken(NativeToken.SCOPE); } else { Log.Step("Serial: operator", args.Peek().Text); args.OutToken(NativeToken.OPERATOR); args.OutByte((byte)opChar); } args.Skip(); }
private static void StatementSerialise(SerialisationArgs args) { var statement = Array.IndexOf(Dict.Statements, args.Peek().Text); if (statement == -1) { return; } var logInfo = $"{args.Peek(0).Text} "; switch (args.Next().Text) { case "each": void OutNextName() => args.OutBytes(GetNameBytes(args.Next().Text, args)); //Determine if with or without iterator if (args.Peek(1).Text == ",") { logInfo += $"\"{args.Peek().Text}\""; args.OutToken(NativeToken.ST_EACHIT); OutNextName(); args.Skip(); //, } else { args.OutToken(NativeToken.ST_EACH); } logInfo += $" \"{args.Peek().Text}\""; OutNextName(); args.Skip(); //: break; } Log.Step("Serial: statement", logInfo); }
private static void NameRefSerialise(SerialisationArgs args) { if (args.Peek().Token != ParseToken.TEXT) { return; } Log.Step("Serial: nameref", args.Peek().Text); args.OutToken(NativeToken.REFERENCE); args.OutBytes(GetNameBytes(args.Peek().Text, args)); args.Skip(); Rate2(args); }
private static void IndentSerialise(SerialisationArgs args) { var isIndent = args.Peek().Token == ParseToken.INDENT; var isDedent = args.Peek().Token == ParseToken.DEDENT; if (!isIndent && !isDedent) { return; } Log.Step("Serial: indent", args.Peek().Text); args.OutToken(isIndent ? NativeToken.INDENT : NativeToken.DEDENT); args.OutByte(byte.Parse(args.Next().Text)); }
private static void AssignSerialise(SerialisationArgs args) { var afterDecl = (args.Peek().Token == ParseToken.OP) && (args.Peek().Text == "="); var other = (args.Peek().Token == ParseToken.TEXT) && (args.Peek(1).Text == "="); if (!afterDecl && !other) { return; } args.OutToken(NativeToken.ASSIGN); if (afterDecl && args.CanPeek(-1)) { Log.Step("Serial: assign", $"{args.Peek(-1).Text}="); args.OutBytes(GetNameBytes(args.Peek(-1).Text, args)); args.Skip(); } else { Log.Step("Serial: assign", $"{args.Peek().Text}="); args.OutBytes(GetNameBytes(args.Peek().Text, args)); args.Skip(2); } //Defer to 2nd Rate Serialiser Rate2(args); }
private static void NewlineSerialise(SerialisationArgs args) { if (args.Peek().Token != ParseToken.ENDLIN) { return; } Log.Step("Serial: newline", ""); args.OutToken(NativeToken.NEWLINE); args.Skip(); }
private static void VarDeclSerialise(SerialisationArgs args) { if (args.Peek().Token == ParseToken.TEXT && args.Peek(1).Token == ParseToken.TEXT) { Log.Step("Serial: vardecl", $"{args.Peek().Text} \"{args.Peek(1).Text}\""); //Are we declaring native, or user type? if (IsNativeType(args.Peek().Text)) { args.OutToken(NativeToken.DECL_NATVAR); args.OutByte((byte)Enum.Parse <NativeDataType>(args.Next().Text)); //type args.OutBytes(GetNameBytes(args.Next().Text, args)); //name } else { args.OutToken(NativeToken.DECL_USERVAR); args.OutBytes(GetNameBytes(args.Next().Text, args)); //type args.OutBytes(GetNameBytes(args.Next().Text, args)); //name } } }
/// <summary>Serialises type with native/user prefix</summary> private static void OutNextType(SerialisationArgs args) { if (IsNativeType(args.Peek().Text)) { args.OutByte(0x10); args.OutByte((byte)Enum.Parse <NativeDataType>(args.Next().Text)); } else { args.OutByte(0x11); args.OutBytes(GetNameBytes(args.Next().Text, args)); } }
private static void LiteralSerialise(SerialisationArgs args) { var log = true; switch (args.Peek().Token) { case ParseToken.NUMBER: if (args.Peek().Text.Contains('.')) { args.OutToken(NativeToken.LIT_FLO); args.OutBytes(BitConverter.GetBytes(float.Parse(args.Next().Text))); } else { args.OutToken(NativeToken.LIT_INT); args.OutBytes(BitConverter.GetBytes(int.Parse(args.Next().Text))); } break; case ParseToken.STRING: args.OutToken(NativeToken.LIT_STR); args.OutBytes(GetStringBytes(args.Next().Text)); break; case ParseToken.CHAR: args.OutToken(NativeToken.LIT_CHR); args.OutByte((byte)char.Parse(args.Next().Text)); break; default: log = false; break; } if (log) { Log.Step("Serial: literal", args.Peek(-1).Text); } }
private static void SubDeclSerialise(SerialisationArgs args) { if (args.Peek().Text != "sub") { return; } var pos = args.Peek().OriginalPos; var subName = args.Peek(1).Text; Log.Step("Serial: subroutine", subName); args.OutToken(NativeToken.DECL_SUB); args.OutBytes(GetNameBytes(subName, args)); args.Skip(2); //sub name //Next byte is: 4-bit scheme, 4-bit 0:native 1:user return type if (args.Peek().Token == ParseToken.ENDLIN || args.Peek().Text == "=>") { //No parameters, no returns args.OutByte(0x00); args.Skip(); } else { if (args.Peek().Text == ":") { //No parameters, returns args.Skip(); //: OutNextType(args); } else if (args.Peek().Text == "(") { byte timeout = 0; while (args.Peek().Text != ")" && timeout++ < 255) { args.Skip(); //( or , OutNextTypeAndName(args); } if (timeout == 255) { Log.Error($"sub `{subName}` parameters unclosed", pos, ""); } else { args.Skip(); //) } } } }
private static void Rate1(SerialisationArgs args) { var prevAtom = 0; while (!args.IsExhausted) { StatementSerialise(args); SubDeclSerialise(args); VarDeclSerialise(args); AssignSerialise(args); NameRefSerialise(args); NewlineSerialise(args); IndentSerialise(args); if (prevAtom == args.CurrentIndex) { Log.Error("End of serialisation competence", args.Peek().OriginalPos, args.Peek().Text); return; } prevAtom = args.CurrentIndex; } }