在开始了解青语言的运行逻辑之前，我们首先来了解一下青语言中一些基础类的定义。

语法核心实现类

Parser.cs / Token

public class Token {
        public string Str { get; set; } = "";
        public int Line { get; set; } = 0;
        public string Src { get; set; } = "标准输入";
        ……
    }

这个类是代码转换到表达式的中间类，记录按语法切割的代码片段、行号和来源文件

Parser.cs / Parser

public class Parser {
        int Line = 1；
        ……
    }

青语言代码的解析类，内部有解析代码的方法，包括将代码切割为Token 序列，和将Token序列转换为表达式序列

Tp.cs / TP

public enum TP {
        Err,    //异常类型
        None,   //空类型
        Bin,    //二进制类型
        Bool,   //逻辑类型
        Int,    //整数类型
        Float,  //小数类型
        Rune,   //字符类型,目前没有使用
        Str,    //字符串类型
        Obj,    //对象类型
        Arr,    //数组类型
        Tag,    //标签类型
        Var,    //变量类型
        Act,    //函数类型
        Path,   //路径类型

        ……
｝

表达式类型的枚举值，用来标记表达式的类型，这里只列出了部分

Expr.cs / Expr

public class Expr {
        public TP Tp { get; set; } = TP.None;
        public object Val { get; set; } = 0;
        public List<Expr>? List { get; set; }
        public int Line { get; set; } = 0;
        public string Src { get; set; } = "标准输入";

        ……
}

青语言中所有的语法元素都称为表达式（这或许不是很准确的名称，我们姑且这么称呼）
表达式可以存放任意的值，通过Tp属性标记其类型
内部的值存放在 Val （单个值） 或者 List（集合或者是语句）
此外还存放了行号和来源文件
这个类是青语言的核心类，内部有对表达式求解的方法，通过对表达式递归求解实现代码功能

Ctx.cs / Ctx

public class Ctx {
        public Dictionary<string, Expr> Map { get; set; } //存储变量的表
        public Ctx? Father; //上级语境
        public CtxTp Tp = CtxTp.Default;
        ……
    }

青语言语境类，类似于作用域，记录变量名和变量值的绑定关系

语法功能实现类

Op.cs / Op

public class Op {
        public static Expr DimVar(List<Expr> args, Ctx ctx) {
        ……

        public static Expr Add(List<Expr> args, Ctx ctx) {
        ……
    }

青语言中所有的中缀运算符功能在这里实现

Native.cs / Native

public abstract class Native {
        public Ctx? Ctx { get; set; } = null;
        public abstract string Name { get; set; }      // 函数名称
        public abstract string Desc { get; set; }       //  函数描述
        public abstract Expr Run(List<Expr> args, Ctx ctx, Obj? obj=null);
    }

青语言中所有的内置原生函数都继承这个抽象类，调用原生函数时执行Run方法

Func.cs / Func

public class Func {
        public List<Expr> Args; //参数列表
        public List<Expr> NamedArgs; //命名参数列表
        public Expr Code; //函数的执行体
        public bool Asy = false; //是否异步函数
        public Ctx? BindCtx = null; //函数绑定的语境
        public string Desc = "…"; //函数的描述信息
        ……
        public Expr Run(List<Expr> realArgs, Ctx ctx) {
        ……
｝

青语言中的自定义函数类，用来存放开发者自定义的函数，调用自定义函数时同样执行Run方法

对象封装类

Obj.cs / Obj

public class Obj : Ctx {
        public object Raw { get; set; }
        ……
｝

青语言中对对象的封装，任意的C#对象都可以放到Raw中
对象本质上就是一个Ctx语境
对象中的属性可以按照语境的方式设置
对象的方法通过实现Native来定义
如果需要封装原生对象的属性，可以使用下面这个类

Obj.cs / Prop

public abstract class Prop {
        public dynamic obj;
        public abstract Expr Qget(Ctx? ctx=null);
        public abstract Expr Qset(Expr val, Ctx? ctx = null);

    }

如果要封装原生对象的属性，那么可以在继承Obj的同时，在内部实现这个Prop类
然后通过Qget和Qset方法间接地操作原生对象的属性

Tag.cs / Tag

public class Tag {
        public Expr Name { get; set; } = Expr.NoneExpr;    //标签名
        public List<Expr> Attrs { get; set; } = new List<Expr>();    //标签属性列表
        public Expr Children { get; set; } = Expr.NoneExpr;   //子标签列表

    }

这个类是预设的标签类型对应的类，用来扩展功能