ton-assembly/dist/text/grammar.d.ts

TON assembler and disassembler

import * as $ from "@tonstudio/parser-runtime";
export declare namespace $ast {
    type File = $.Located<{
        readonly $: "File";
        readonly instructions: instructions;
    }>;
    type Instruction = $.Located<{
        readonly $: "Instruction";
        readonly name: Id;
        readonly args: readonly Argument[];
    }>;
    type ExplicitRef = $.Located<{
        readonly $: "ExplicitRef";
        readonly code: Code;
    }>;
    type EmbedSlice = $.Located<{
        readonly $: "EmbedSlice";
        readonly data: DataLiteral;
    }>;
    type Exotic = $.Located<{
        readonly $: "Exotic";
        readonly lib: ExoticLibrary | DefaultExotic;
    }>;
    type instructions = readonly (Instruction | ExplicitRef | EmbedSlice | Exotic)[];
    type Argument = $.Located<{
        readonly $: "Argument";
        readonly expression: IntegerLiteral | DataLiteral | Code | Dictionary | StackElement | ControlRegister;
    }>;
    type StackElement = $.Located<{
        readonly $: "StackElement";
        readonly value: string;
    }>;
    type ControlRegister = $.Located<{
        readonly $: "ControlRegister";
        readonly value: string;
    }>;
    type Code = $.Located<{
        readonly $: "Code";
        readonly instructions: instructions;
    }>;
    type Dictionary = $.Located<{
        readonly $: "Dictionary";
        readonly entries: readonly DictionaryEntry[];
    }>;
    type DictionaryEntry = $.Located<{
        readonly $: "DictionaryEntry";
        readonly id: IntegerLiteral;
        readonly code: Code;
    }>;
    type ExoticLibrary = $.Located<{
        readonly $: "ExoticLibrary";
        readonly data: DataLiteral;
    }>;
    type DefaultExotic = $.Located<{
        readonly $: "DefaultExotic";
        readonly data: DataLiteral;
    }>;
    type idPart = string | string | string | "_";
    type Id = $.Located<{
        readonly $: "Id";
        readonly name: string;
    }>;
    type DataLiteral = $.Located<{
        readonly $: "DataLiteral";
        readonly value: HexLiteral | BinLiteral | BocLiteral | StringLiteral;
    }>;
    type HexLiteral = $.Located<{
        readonly $: "HexLiteral";
        readonly content: string;
    }>;
    type BinLiteral = $.Located<{
        readonly $: "BinLiteral";
        readonly content: string;
    }>;
    type BocLiteral = $.Located<{
        readonly $: "BocLiteral";
        readonly content: string;
    }>;
    type IntegerLiteral = $.Located<{
        readonly $: "IntegerLiteral";
        readonly op: "-" | undefined;
        readonly value: IntegerLiteralHex | IntegerLiteralBin | IntegerLiteralOct | IntegerLiteralDec;
    }>;
    type IntegerLiteralDec = $.Located<{
        readonly $: "IntegerLiteralDec";
        readonly digits: underscored<digit>;
    }>;
    type IntegerLiteralHex = $.Located<{
        readonly $: "IntegerLiteralHex";
        readonly digits: string;
    }>;
    type IntegerLiteralBin = $.Located<{
        readonly $: "IntegerLiteralBin";
        readonly digits: string;
    }>;
    type IntegerLiteralOct = $.Located<{
        readonly $: "IntegerLiteralOct";
        readonly digits: string;
    }>;
    type underscored<T> = string;
    type hexDigit = string | string | string;
    type binDigit = "0" | "1";
    type digit = string;
    type StringLiteral = $.Located<{
        readonly $: "StringLiteral";
        readonly value: string;
    }>;
    type keyword<T> = T;
    type reservedWord = keyword<"ref" | "embed" | "exotic" | "library">;
    type singleLineComment = string;
    type comment = singleLineComment;
    type space = " " | "\t" | "\r" | "\n" | comment;
}
export declare const File: $.Parser<$ast.File>;
export declare const Instruction: $.Parser<$ast.Instruction>;
export declare const ExplicitRef: $.Parser<$ast.ExplicitRef>;
export declare const EmbedSlice: $.Parser<$ast.EmbedSlice>;
export declare const Exotic: $.Parser<$ast.Exotic>;
export declare const instructions: $.Parser<$ast.instructions>;
export declare const Argument: $.Parser<$ast.Argument>;
export declare const StackElement: $.Parser<$ast.StackElement>;
export declare const ControlRegister: $.Parser<$ast.ControlRegister>;
export declare const Code: $.Parser<$ast.Code>;
export declare const Dictionary: $.Parser<$ast.Dictionary>;
export declare const DictionaryEntry: $.Parser<$ast.DictionaryEntry>;
export declare const ExoticLibrary: $.Parser<$ast.ExoticLibrary>;
export declare const DefaultExotic: $.Parser<$ast.DefaultExotic>;
export declare const idPart: $.Parser<$ast.idPart>;
export declare const Id: $.Parser<$ast.Id>;
export declare const DataLiteral: $.Parser<$ast.DataLiteral>;
export declare const HexLiteral: $.Parser<$ast.HexLiteral>;
export declare const BinLiteral: $.Parser<$ast.BinLiteral>;
export declare const BocLiteral: $.Parser<$ast.BocLiteral>;
export declare const IntegerLiteral: $.Parser<$ast.IntegerLiteral>;
export declare const IntegerLiteralDec: $.Parser<$ast.IntegerLiteralDec>;
export declare const IntegerLiteralHex: $.Parser<$ast.IntegerLiteralHex>;
export declare const IntegerLiteralBin: $.Parser<$ast.IntegerLiteralBin>;
export declare const IntegerLiteralOct: $.Parser<$ast.IntegerLiteralOct>;
export declare const underscored: <T>(T: $.Parser<T>) => $.Parser<$ast.underscored<T>>;
export declare const hexDigit: $.Parser<$ast.hexDigit>;
export declare const binDigit: $.Parser<$ast.binDigit>;
export declare const digit: $.Parser<$ast.digit>;
export declare const StringLiteral: $.Parser<$ast.StringLiteral>;
export declare const keyword: <T>(T: $.Parser<T>) => $.Parser<$ast.keyword<T>>;
export declare const reservedWord: $.Parser<$ast.reservedWord>;
export declare const singleLineComment: $.Parser<$ast.singleLineComment>;
export declare const comment: $.Parser<$ast.comment>;
export declare const space: $.Parser<$ast.space>;
//# sourceMappingURL=grammar.d.ts.map