Pinkman

导航

统计

从头学习compiler系列2——COOL语言学习1

        
    Cool语言是一个面向对象的语言。虽然比较小型,但也包含了许多现代语言的特性,如对象、强类型和自动化内存管理。如果你之前熟悉c++、java等面向对象语言,那么会很容易上手。
    学一门新语言,最急迫想知道的就是,如何编写“hello world”程序,下面就来尝个鲜。
    class Main inherits IO {
       main(): SELF_TYPE {
        out_string("Hello, World.\n")
       };
    };
    打眼一看,外形很像java,其实意思也很相近了。下面我来细细详谈。全文大部分翻译cool语言手册。
 

1,类结构 classes

    一个Cool程序是由许多的类组成,每个类的定义必须在一个源文件里。但是多个类可以定义在一个源文件中。类的形式:
    class <type> [ inherits <type> ] {
        <feature_list>
    };
    <type>代表类名,[]里的内容是可选项。{}内是feature集合。所有类名都是全局可见的。类名是以大写字母开头的字符串。类不能重复定义(不能有两个类名字相同)。
    “hello world”例子,就只有一个类,名字是Main。
    

2,features

    feature也就是我们说的函数和属性的统称。一个类是由数个features组成。
 

    2.1 函数 methods

    函数结构如下:
    <id> ( <id> : <type> , ... , <id> : <type>) : <type> { <expr> }
    <id>是标示符,也就是名字。<type>是类型。<expr>是表达式。()里面是函数的形参定义。例如:
    add ( a   :  Int, b : Int ) : Int {
        a + b
    }
    add是函数名,a和b是参数名字,":"后跟着的是参数的类型。") :"后跟着的是返回类型。{}里面就是函数内容,也就是表达式组成。表达式后面会讲到。
    类函数是外部可见的,也就是外部可以调用类的任何函数。        
    函数参数可以有1个或更多,也可以没有,并且参数的名字不能相同。函数的返回值必须明确给出。如果参数的名字和类属性名字相同,那么就会隐藏掉类属性。也就是说在这个函数里,参数和类属性名字相同,那么同名用的都是参数。

    2.2 属性 attributes

    属性结构如下:
    <id> : <type> [ <- <expr> ];
    <id>是属性名,<type>是属性类型。[]是可选的,属性的初始化。也就是把<expr>表达式的值赋给<id>。例如:
    class A {
        x : Int <- 1;
    }
    类A有一个属性为Int型的x,初始化为1。
    初始化操作是在新建立一个类的对象的时候进行。在一个类内,属性初始化的顺序就是定义的顺序。类属性是局部变量,是类私有的。外部不能直接访问类的属性,只能通过函数去修改值。这也体现了现代OO语言的封装性。
    所有的属性,如果没有指定初始化,那么默认初始为void。void类似于c语言里面的NULL,或者java里的null。不过在Cool语言里没有void的定义。唯一一个创建void值得方法就是在某个类里建立一个变量,除了Int,String,Bool类,并让这个void初始化,或者保存while循环的结果。有一个表达式isvoid expr,用来判断expr的值是不是void(会在之后表达式里讲到)。
    基础类Int,Bool和String的属性定义和初始化是特殊的,会在后面基础类里讲到。
 

3,继承 inherits

    继承的结构如下:
    class C inherits P { ... }
    类C是类P的子类,类P是类C的父类。
    类C除了自己定义的features,还继承了所有父类P的所有features。如果子类父类定义了相同的函数,那么子类函数有更高的优先级。子类父类不定定义相同名字的属性。
    有一个特殊的类Object(后面基础类会讲到)。如果一个类没有继承任何类,那么会默认的继承类Object。子类最多只能继承一个父类,这也叫做“单继承”。根据类的父子关系,可以定义一个集成体系图。这个图不能包含环。例如:类C继承类P,类P就不能继承类C。如果类C继承类P,那么类P必须在程序中有定义。因为是单继承,所以形成的图是一个树形结构,根节点就是类Object。
    新对象建立,所有的基类的属性也都要初始化操作,基类优先,逐步向外。
    为了确保类型安全,继承的函数有一些限制。规则很简单:如果子类C从父类P继承了函数f,那么类C必须覆盖类P中f的定义,参数和返回类型必须保持一致。
    class P {
        f(): Int { 1 };
    };
    class C inherits P {
        f(): String { "1" };
    };
    如果p是动态类型类P的对象,那么p.f() + 1的值就是2。但是如果p赋值为类C的对象,那么结果为string + Int,也就会出现问题。也就是如果子类随意的覆盖父类的函数,那么就不是对父类函数行为的扩展,继承也就没有作用。
 

4,类型 types

    在Cool语言里,每一个类名也是一个类型。SELF_TYPE类型用在比较特殊的场合。
    类型声明通过x : C的方式。x是变量,C是类型。在使用一个变量前,这个变量必须声明过。
    在Cool里有一个基本规则。如果类C继承类P,那么用到P的值地方,也可以用C的值代替。
    如果类C的值可以代替类P的值,那么我们说C从属于P,或者表示为C《 P(可以认为类C是继承树的位置更低)。就像上面所说的那样,从属关系根据的是继承树。
    定义,A,C和P都是类型:
        A 《 A
        如果 C继承P,那么C《 P
        如果A《 C,并且C 《 P,那么A 《 P
        因为Object是继承树的根节点,所有对于所有类型A,都有A 《 Object
    

   4.1 SELF_TYPE

        SELF_TYPE就是self变量的类型。在继承的时候很好用,尤其是当避免写类的具体类型。举个例子:
        class Silly {
            copy() : SELF_TYPE { self };
        };
        class Sally inherits Silly { };
        class Main {
            x : Sally <- (new Sally).copy();
            main() : Sally { x };
        }; 
        Silly的copy函数返回值的SELF_TYPE,那就意味着返回的是类调用者的类型。所以子类Sally调用copy函数,返回的也是Sally,而不是Silly。
        我们可以注意到,SELF_TYPE类型并不是固定的,是根据相关类哪里出现。
        还有一个用法,就是: new SELF_TYPE,可以作为函数的返回类型,或者let变量的类型声明,或者属性的声明。除此之外,其它的用法是错误的。
 

    4.2 类型检查 Type Checking

        Cool的类型检查系统保证在编译期通过的程序,不会在运行时候出现类型错误。程序员需要提供变量的类型,然后类型检查器就会据此在程序用到的地方来推断类型。
        在编译期,类型检查器给变量定义类型,我们叫它表达式的静态类型;在运行期一个表达式的计算的类型值,称为动态类型。
        有这种区别是因为,在编译器,类型检查器没有在运行期时的动态数据,所以一般区别这两种类型。然而我们关心的是静态类型,可以保证程序运行时正确性。
 

5,表达式 expressions

    5.1 常量 Constants

        最简单的表达式就是常量。布尔常量是true或false。整型常量是无符号的字符串,如:0,123,007. 字符串常量是被两个双引号包围的字符序列,例如:"this is a string." 字符串之多只能有1024个字符长度。
        这三个常量分别对应三个基础类:Bool,Int,String。

    5.2 标示符 Identifiers

        局部变量的名字,函数的参数名字,self,和类的属性都是标示符。self标示符可以被调用,但是不能给self赋值,或者在let、case或者函数参数里绑定它。也不允许把类属性命名为self。
        局部变量和函数参数都有词法控件约束。类属性的作用域在那个类或继承的类里,尽管它可能被同名局部变量锁隐藏。绑定的标示符作用在声明的最内层空间。一个例外就是self,永远表示的每个类。

    5.3 分配 Assignment

        形式结构如下:
        <id> <- <expr>
        expr表达式的静态类型必须从属于id的声明类型。分配表达式的值就是expr的值,分配表达式的静态类型就是expr的静态类型。

    5.4 函数调用 Dispatch

        在Cool里,有三种形式的函数调用。之间的区别取决于如何选择调用函数。最常见的形式是:
        <expr>.<id>(<expr>, ... ,<expr>)
        考虑一个一般的形式 e0.f(e1, ... ,en). 要计算整个表达式的值,先要计算参数的值。先从e1开始,从左到右直到en计算出值。下一步计算e0的值,查看e0属于哪个类C(e0值如果是void,那么就会产生一个运行时错误)。最后,调用类C的函数f,并且e0的值绑定到函数f的self变量,实参绑定到形参里。Dispatch表达式的值,就是函数的返回值。
        函数调用的类型检查包括很多步。假设e0的静态类型是A。那么A必须有一个函数f,这个f的参数和调用的参数数量必须相同,并且每个参数对应的静态类型也必须符合。
        如果函数返回类型B,并且B是一个类名。那么Dispatch表达式的静态类型就是B。相反,如果函数f返回类型为SELF_TYPE,那么Dispatch的静态类型就是A。因为函数f里的self变量绑定的是类A,返回SELF_TYPE类型,所以我们推断返回类型的结果就是类A。
        其它的两种调用形式:
            <id>(<expr>, ... ,<expr>)
            <expr>@<type>.id(<expr>, ... ,<expr>)
            前一种形式是 self.<id>(<expr>, ... ,<expr>)的简写形式。
        后一种形式提供了一个方法,用来调用父类的函数。如果子类覆盖了父类的函数,那么子类里只能调用子类定义的函数,父类函数因为隐藏掉了。这种形式指定了类型,所以就可以调用继承关系任意类的函数。例如:e @B.f()调用类B的函数f。但是e的类型必须从属于类B,也就是说必须是类B或B的子类。

    5.5 条件 Conditionals

        条件的形式如下:
        if <expr> then <expr> else <expr> fi
        一个标准的条件语法。先判断第一个expr的值,如果是true,那么就计算then后expr的值;如果是false,那么就计算else后expr的值,fi表示条件语句结束。条件语句的值,就是所属分支的值。
        第一个expr的静态类型必须是类型Bool,各分支没有限制。至于条件表达式的类型,我们先定义一个符号“U",让A,B,D为出了SELF_TYPE的任意一个类型。那么有:
            A U B = C (C类型是A和B共同从属的最小类型,也就是A、B相同的最小父类,小的意思是子类比父类小)
            A U A = A
            A U B = B U A
            SELF_TYPE U A = D U A  (假如SELF_TYPE指定类型D)
        T代表为真的表达式的静态类型,F代表为假的表达式的静态类型。那么整个条件表达式的静态类型为T U F。
 

    5.6 循环 Loops

        循环的形式如下:
        while <expr> loop <expr> pool
        先计算第一个expr的值,如果类型是true,那么计算第二个expr值,然后回到第一个expr计算;如果false,那么整个循环表达式返回void。第一个expr的静态类型必须是Bool。循环表达式的静态类型是类Object。

    5.7 代码块 Blocks

        代码块的形式如下:
        { <expr>; .. <expr>;}
        表达式的计算顺序是从左到右。每一个代码块必须至少有一个表达式;代码块的值就是最后一个表达式的值。代码块的静态类型是最后一个表达式的静态类型。
        在Cool里,很容易把";”号用错。分号是表达式的终结符,不是表达式的分隔符。详细例子以后遇见了会介绍。

    5.8 Let 表达式

        let表达式形式如下:
        let <id1> : <type1> [ <- <expr1> ], ... , <idn> : <typen> [ <- <exprn> ] in <expr>
        初始化的表达式如<expr1>是可选择的。如果有,先计算<expr1>的值,绑定到<id1>;然后在计算<expr2>,绑定到<id2>。如此顺序直到<idn>。接下来进行let的主体,in后面的<expr>的计算。let的值也就是主体表达式的值。
        <id1>到<idn>只有在let的主体里才是可见。并且当m > k对于<idm>,<idk>是可见的。
        如果let定义的标示符名字重复,那么前面定义的会被隐藏掉。每个let必须至少声明一个标示符。
        每个初始化表达式的类型必须从属于标示符声明的类型。主体表达式的类型就是let的类型。

    5.9 分支 Case

        case形式如下:
        case <expr0> of
            <id1> : <type1> => <expr1>;
            . . .
            <idn> : <typen> => <exprn>;
        esac
        case提供了运行时的检测。首先,计算<expr0>的动态类型为C(如果类型为void,那么会报运行时错误)。下一步,找出符合条件的分支。当C 《 <typek>,那么就选择这个类型的分支。<idk>绑定<expr0>的值,然后计算<exprk>。如果没有一个分支符合,那么产生一个运行时错误。每个case必须至少包含一个分支。
        设Ti为<expri>的静态类型,那么T1 U T2 U ... U Tn就是case的静态类型。分支里声明的<idk>,作用域在<exprk>里,并且隐藏了外部同名的标示符。
        case没有特殊的结构代表“default”或“otherwise”的分支。有一个相同的效果是包含分支:
            x : Object => ...
            因为每个类型都有 《 Object。
        case提供程序员一个进行运行时类型检测的方法,之前的都是类型检测器推断的保守的静态类型。一个典型的应用场合:程序员写一个表达式e,并检测e是否有静态类型P。然而事实上这个程序员可能知道e的动态类型总是C(C 《 P)。如下写法可以捕获这个信息:
            case e of x : C => ...
        在这个分支里,x绑定了更具体的静态类型C的e表达式的值。

    5.10 New 表达式

        new的形式如下:
        new <type>
        根据<type>申请一个新的类。如果类型是SELF_TYPE,那么会根据当前空间self绑定的对象类型来建立。new的静态类型为<type>。

    5.11 Isvoid

        isvoid的形式如下:
        isvoid expr
        如果expr值为true,那么isvoid为true;如果expr值为not void,那么isvoid为false。
 

6,基础类 basic classes

    Object

        Obejct类是继承树的根节点类。定义了以下函数:
            abort() : Object
            type_name() : String
            copy() : SELF_TYPE
        abort()函数会终止程序,并携带错误信息。type_name函数返回类的名字。copy函数是对自身的一个浅拷贝(浅拷贝就是拷贝自身,不进行指针指向的内存拷贝)。

    IO

        提供了一些简单的输入输出操作函数:
            out_stirng( x : String ) : SELF_TYPE
            out_int( x : Int) : SELF_TYPE
            in_string() : String
            in_int() : Int
        out_string和out_int函数打印参数并返回self。in_string函数从标准输入读入一个字符串,直到有一个换行符。in_int函数读入一个整型,直到一个空格。任何在整型之后的字符,直到并包括下个换行符,那么这个整型会被丢掉。
        一个类可以继承IO来用IO的函数。不能重新定义IO类。

    Int

        Int类是提供整型。这个类没有函数。默认初始化时0(不是void)。不能继承或重定义Int。

    String

        String类提供字符串。定义了以下函数:
            length() : Int
            concat( s : String) : String
            substr( i : Int, l : Int) : String
        length函数返回self参数的长度。concat函数连接self和s字符串。substr函数返回self参数从位置i到l的字串(从0 开始计算)。如果超界了,会产生一个运行时错误。
        默认的初始化为""(不是void)。不能继承或重定义String。

    Bool

        Bool类提供true和false。默认的初始化是false(不是void)。不能继承或重定义Bool。
 

7,Main Class

    每个程序必须有一个类Main,并且Main里必须有一个没有参数的函数main。main函数必须在Main里定义(不能通过继承其它类)。程序通过(new Main).main()来执行。

8,注释 Comments

    Cool里有两种注释。
    一种是以"--"开头,直到行尾都被注释掉。
    一种注释以"(*"和"*)"包围着。
 
—— Pinkman



posted on 2013-03-12 00:10 Pinkman 阅读(...) 评论(...) 编辑 收藏