• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

// Recode 1.0
// http://llf.hanzify.org
// http://llf.javaeye.com
// 作者：梁利锋
using System;
using System.IO;
using System.Text;
using System.Windows.Forms;

namespace Recode
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void FileCollector_DragOver(object sender, DragEventArgs e)
        {
            e.Effect = DragDropEffects.Link;
        }

        private void FileCollector_DragDrop(object sender, DragEventArgs e)
        {
            var list = (Array) e.Data.GetData(DataFormats.FileDrop);
            if (list != null && list.Length > 0)
            {
                FileCollector.Items.Clear();
                foreach (object f in list)
                {
                    string s = f.ToString();
                    if (File.Exists(s))
                    {
                        FileCollector.Items.Add(s);
                    }
                }
            }
            FileCount.Text = FileCollector.Items.Count.ToString();
        }

        private void Run_Click(object sender, EventArgs e)
        {
            if (FileCollector.Items.Count > 0)
            {
                foreach (string name in FileCollector.Items)
                {
                    RecodeOneFile(name);
                }
                MessageBox.Show("done!");
            }
            else
            {
                MessageBox.Show("Please drag and drop some files to the list box first.");
            }
        }

        private static void RecodeOneFile(string name)
        {
            string content;
            using (var sr = new StreamReader(name, Encoding.GetEncoding(1252))) // 英文代码页
            {
                content = sr.ReadToEnd();
            }

            using (var sw = new StreamWriter(name, false, Encoding.UTF8))
            {
                sw.Write(content);
            }
        }
    }
}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

function get_CheckBox(theCell)
{
       for(var i = 0; i < theCell.childNodes.length; i++)
       {
           if(theCell.childNodes[i].id)
           {
                return theCell.childNodes[i];
           }
       }
}

function select_all(obj)
{
    var theTable  = obj.parentNode.parentNode.parentNode;
    var j = obj.parentNode.cellIndex;

    for(var i=0; i<theTable.rows.length; i++)
    {
        var objCheckBox = get_CheckBox(theTable.rows[i].cells[j]);
        if(objCheckBox.checked != null)
            objCheckBox.checked = obj.checked;
    }
}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

subMock.Receive(message);
Expect.On(subMock).Call(subMock.MultiplyTwo(5)).Return(10);
mocks.ReplayAll();

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

public class Category
{
    private static int IdSeed = 1;

    public int Id { get; set; }
    public string Name { get; set; }

    public Category()
    {
        Id = IdSeed++;
    }
}

public class Link
{
    private static int IdSeed = 1;

    public int Id { get; set; }
    public string Name { get; set; }
    public string Url { get; set; }
    public int Permission { get; set; }
    public bool Hide { get; set; }
    public int Category_Id { get; set; }

    public Link()
    {
        Id = IdSeed++;
    }
}

public static class Navigation
{
    public static readonly List<Category> Categories;
    public static readonly List<Link> Links;
}

static Navigation()
{
    Categories = new List<Category>()
    {
        new Category(){ Id = 1, Name = "设备管理" },
        new Category(){ Id = 2, Name = "内容管理" },
        new Category(){ Id = 3, Name = "计划" },
        new Category(){ Id = 4, Name = "系统" },
    };

    int FullPermission = (int)(SysUserRole.管理员 | SysUserRole.编辑人员 | SysUserRole.审核人员);

    Links = new List<Link>()
    {
        new Link(){ Url = "Default", Permission = FullPermission, Hide = true },
        // 设备管理
        new Link(){ Name = "新建设备", Url = "PlayerEdit", Permission = FullPermission, Category_Id = 1 },
        new Link(){ Name = "设备列表", Url = "PlayerList", Permission = FullPermission, Category_Id = 1 },
        new Link(){ Url = "PlayerManager", Permission = FullPermission, Hide = true, Category_Id = 1 },
        new Link(){ Category_Id = 1 },
        new Link(){ Name = "新建分组", Url = "PlayerGroupEdit", Permission = FullPermission, Category_Id = 1 },
        new Link(){ Name = "分组列表", Url = "PlayerGroupList", Permission = FullPermission, Category_Id = 1 },
        // 内容管理
        ......
        // 计划
        ......
        // 系统
        new Link(){ Name = "新建帐户", Url = "SysUserEdit", Permission = FullPermission, Category_Id = 4 },
        new Link(){ Name = "帐户列表", Url = "SysUserList", Permission = FullPermission, Category_Id = 4 },
        new Link(){ Category_Id = 4 },
        new Link(){ Name = "新建客户", Url = "CustomerEdit", Permission = FullPermission, Category_Id = 4 },
        new Link(){ Name = "客户列表", Url = "CustomerList", Permission = FullPermission, Category_Id = 4 },
    };
}

public static string BuildNavigator(int Permission)
{
    HtmlBuilder hb = HtmlBuilder.New.div.id("accmenu").enter();
    foreach (var c in Categories)
    {
        int count = 0;
        var b = HtmlBuilder.New.tab.div.enter();
        b.tab.tab.div.Class("acctitle").text(c.Name).end.enter();
        b.tab.tab.div.enter();
        var list = Links.Where(p => p.Category_Id == c.Id).ToList();
        foreach (var n in list)
        {
            if (string.IsNullOrEmpty(n.Url))
            {
                b.include("\t\t\t<hr />\r\n");
            }
            else
            {
                if (!n.Hide && (n.Permission & Permission) == Permission)
                {
                    count++;
                    b.include("\t\t\t<img src=\"images/h2.gif\" align=\"absmiddle\" /> ");
                    b.a(n.Url + ".aspx").text(n.Name).end.br.enter();
                }
            }
        }
        b.tab.tab.end.enter().tab.end.enter();
        if (count > 0)
        {
            hb.include(b);
        }
    }
    hb.end.enter();
    return hb.ToString();
}

<div id="accmenu">
    <div>
        <div class="acctitle">设备管理</div>
        <div>
            <img src="images/h2.gif" align="absmiddle" /> <a href="PlayerEdit.aspx">新建设备</a><br />
            <img src="images/h2.gif" align="absmiddle" /> <a href="PlayerList.aspx">设备列表</a><br />
            <hr />
            <img src="images/h2.gif" align="absmiddle" /> <a href="PlayerGroupEdit.aspx">新建分组</a><br />
            <img src="images/h2.gif" align="absmiddle" /> <a href="PlayerGroupList.aspx">分组列表</a><br />
        </div>
    </div>
    <div>
        ......
    </div>
    <div>
        ......
    </div>
    <div>
        <div class="acctitle">系统</div>
        <div>
            <img src="images/h2.gif" align="absmiddle" /> <a href="SysUserEdit.aspx">新建帐户</a><br />
            <img src="images/h2.gif" align="absmiddle" /> <a href="SysUserList.aspx">帐户列表</a><br />
            <hr />
            <img src="images/h2.gif" align="absmiddle" /> <a href="CustomerEdit.aspx">新建客户</a><br />
            <img src="images/h2.gif" align="absmiddle" /> <a href="CustomerList.aspx">客户列表</a><br />
        </div>
    </div>
</div>

jQuery().ready(function(){
    var w = $('#accmenu').accordion({
        header: 'div.acctitle',
        animated: false
    });
    w.activate(CategoryIndex);
});

public static int GetPermission(string Url)
{
    var item = Links.Where(p => p.Url == Url).ToList();
    if (item.Count > 0)
    {
        return item[0].Permission;
    }
    return 0;
}

public static int GetIndex(string Url, int Permission)
{
    int id = FindCategoryId(Url);
    var item = from p in Links where (p.Permission & Permission) == Permission && p.Category_Id != 0
               group p by p.Category_Id into g select new { Category_Id = g.Key };
    var i = item.ToList().FindIndex(p => p.Category_Id == id);
    return i < 0 ? 0 : i;
}

public static int FindCategoryId(string Url)
{
    var item = Links.Where(p => p.Url == Url).ToList();
    if (item.Count > 0)
    {
        return item[0].Category_Id;
    }
    return 0;
}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

// 行注释
/* 注释 */
/+ 嵌套注释 +/

int a = 123_456_789;

bool b = true;
b = 30 > 10;

auto a = 1;
auto b = true;
if(b) write(a);

int a = 0x83_af; // 十六进制数字
int b = 067;     // 八进制数字

a = b = c = 2;

int n = 10;
int a *= ++n;

// 1 到 100 的和
// for 循环
int n = 0;
for(int i=1; i<=100; ++i)
    n += i;
write(n);
// while 循环
i = 0; n = 0;
while( i < 100 )
    n += ++i;
write(n);
// do-while 循环
i = 0; n = 0;
do
    n += ++i;
while( i < 100 )
write(n);

int a = 10;
int b=5-3;    // 5 - 3
b=5--3;       // 5 - (-3);
b=7*-a;       // 7 * (-a);

int n = 1;
bool a = n == 0;
a = a && n > 10 || n != 3;
bool b = n; // error
if(b) write(1);
if(n) write(2); // error

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

　　开始把 D 的语法转换为 EBNF，发现 D 还支持中文变量名，也就是所谓的 UniversalAlpha，查看了一下 dmd front end 的源代码，检查字符是否 UniversalAlpha 的函数是这样的：

int isUniAlpha(unsigned u)
{
    static unsigned short table[][2] =
    {
 { 0x00AA, 0x00AA },
 { 0x00B5, 0x00B5 },
 { 0x00B7, 0x00B7 },
 ......
 ......
 ......
 { 0x3105, 0x312C },
 { 0x4E00, 0x9FA5 },
 { 0xAC00, 0xD7A3 },
    };
    if (u > 0xD7A3)
 goto Lisnot;

   // Binary search
    int mid;
    int low;
    int high;

  low = 0;
    high = sizeof(table) / sizeof(table[0]) - 1;
    while (low <= high)
    {
 mid = (low + high) >> 1;
 if (u < table[mid][0])
     high = mid - 1;
 else if (u > table[mid][1])
     low = mid + 1;
 else
     goto Lis;
    }

Lisnot:
    return 0;

Lis:
    return 1;
}

　　但是，怎么让 Grammatica 在分析过程中调用类似的函数，却是一点儿头绪也没有。虽然，理论上来说，用正则表达式，也可以表示上面的逻辑，不过，200多行的数据，要都转成正则表达式，不止运行速度慢，就只是转换的工作量，也让人不可接受。

　　而后，对于 D 中 string interger 和 float 的转换，再次发现 Grammatica 这种只用正则表达式的方式的严重不足，终于决定放弃 Grammatica。

　　本来，最好的办法其实是使用 dmd 的前端的源代码来解析，不过，几乎 1.6M 的代码，没有任何文档，都读过一遍的话，黄花菜都凉了。

　　一直不想用 ANTLR 的原因，是语法文件和嵌入的代码混编，看起来杂乱无章，但是 ANTLR 的强大和社区的活跃确实是很吸引人的。于是，决定用 ANTLR 来写 D Parser。（看到还有一个叫 coco/r 的生成器，据说比 ANTLR 清晰，不过也有语法能力不如 ANTLR 的问题，所以暂时也不考虑了。）

　　同样的，四则运算是一个比较好的例子，从 ANTLR 的主页的“五分钟教程”中，找到一个四则运算的语法文件，看了一下，不嵌入代码的话，还挺清晰的。既然用 ANTLR，就要体验一下它自动建立抽象语法树的能力，把那个语法文件做了一些修改，成为这个样子：

grammar SimpleCalc;

options {
    language=CSharp;
    output=AST;
    ASTLabelType=CommonTree;
}

tokens {
    PLUS     = '+' ;
    MINUS    = '-' ;
    MULT     = '*' ;
    DIV      = '/' ;
}

@members {
}

/*------------------------------------------------------------------
 * PARSER RULES
 *------------------------------------------------------------------*/

expr    : term ( ( PLUS^ | MINUS^ )  term )* ;
term    : factor ( ( MULT^ | DIV^ ) factor )* ;
factor  : NUMBER | '(' expr ')' -> expr ;

/*------------------------------------------------------------------
 * LEXER RULES
 *------------------------------------------------------------------*/

NUMBER     : (DIGIT)+ ;
WHITESPACE : ( '\t' | ' ' | '\r' | '\n'| '\u000C' )+     { $channel = HIDDEN; } ;
fragment DIGIT    : '0'..'9' ;

　　做了修改的地方是，1.让它输出 AST，2.把运算符提取为根，3.支持括号。

　　生成文件后，在 Program 文件中加入创建分析器的代码，再加入深度优先的语法树访问函数，以及运算部分如下：

using System;
using System.Collections.Generic;
using System.Text;
using Antlr.Runtime;
using Antlr.Runtime.Tree;

namespace Expr
{
    class Program
    {
        private static Stack<int> numbers = new Stack<int>();

       static void Main(string[] args)
        {
            SimpleCalcLexer lex = new SimpleCalcLexer(new ANTLRFileStream(args[0]));
            CommonTokenStream tokens = new CommonTokenStream(lex);
            SimpleCalcParser parser = new SimpleCalcParser(tokens);

           try
            {
                CommonTree ct = (CommonTree)parser.expr().Tree;
                VisitTree(ct);
                Console.WriteLine("The result is: {0}", numbers.Pop());
                Console.Read();
            }
            catch (RecognitionException e)
            {
                Console.Error.WriteLine(e.StackTrace);
            }
        }

       static void VisitTree(ITree it)
        {
            for (int i = 0; i < it.ChildCount; i++)
            {
                ITree c = it.GetChild(i);
                VisitTree(c);
            }
            switch (it.Type)
            {
                case SimpleCalcLexer.PLUS:
                case SimpleCalcLexer.MINUS:
                case SimpleCalcLexer.MULT:
                case SimpleCalcLexer.DIV:
                    Operation(it.Text, numbers.Pop(), numbers.Pop());
                    break;
                case SimpleCalcLexer.NUMBER:
                    numbers.Push(int.Parse(it.Text));
                    break;
            }
        }

    static void Operation(string opCode, int v2, int v1)
        {
            int result;
            switch (opCode)
            {
                case "+":
                    result = v1 + v2;
                    break;
                case "-":
                    result = v1 - v2;
                    break;
                case "*":
                    result = v1 * v2;
                    break;
                case "/":
                    result = v1 / v2;
                    break;
                default:
                    throw new Exception();
            }
            Console.WriteLine("{1} {0} {2} = {3}", opCode, v1, v2, result);
            numbers.Push(result);
        }
    }
}

　　上面的代码，除了运算之外，还会把每一个计算步骤打印出来，在输入文件中输入“5-(3-2)+6*7”，编译运行程序，得到结果：

　　ANTLR 帮助建立 AST 的功能确实很舒服，而且例子也多，嗯，以后就用它了。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

　　终于把 Z 语言的编译器做完了。意外的在四则运算上耽误了很多时间，发现 Grammatica 的四则运算的例子其实是右结合的，费了很大劲才解决了。现在觉得 Grammatica 的完整度好像不是很高，比如没有帮助建立抽象语法树的工具之类。也许 ANTLR 会好一点儿吧。

　　重新整理了目录，把生成的程序放到了 bin 目录下，建立了一个 build.bat 的批处理，用来把 z 编译成机器码，再打开虚拟机，加载此机器码。

　　虚拟机指令增加了一些，比如现在也支持减、乘、除运算，增加直接设置 esp 和把 esp 和 ebx 转移，以及中断指令（在 z 里通过 pause 语句生成中断指令）等等。

　　Z 的编译器使用的是最保守的方式生成指令，也就是说，为了保证正确性，加入了很多垃圾代码。

　　有一个小问题，就是如果遇到“5-3”这样的表达式，分辨不出是减号还是负号，会编译通不过，解决方法也很简单，加入空格就可以了“5 - 3”。

　　现在，我们可以编译下面的 1 到 100 和的程序：

int n = 0;
int i = 1;
next:
if(i <= 100)
{
    n = n + i;
    i = i + 1;
    goto next;
}
write(n);

　　也可以把 fibonacci 序列的程序编译：

int i=0;
int a=1;
write(a);
int b=1;
write(b);
int t;
next:
t = a + b;
write(t);
a = b;
b = t;
i = i + 1;
if(i<10) goto next;

　　其中，if 语句也可以处理 else：

int n = 1;
int m = 8 * 9;
if( n < 5 && (m == 73 || !(n != 1)) )
{
    write(1);
    if ( n == 1 )
        if ( n == 2 )
            write(11);
        else
            write(12);
}
else
{
    write(2);
}
write(3);

　　或者执行复杂运算如下：

write( 2 + 8 * 1 / 8 - 1 - (2 - 3) * 5 * 2 );

　　下面是可执行文件、源代码和运行截图：

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

　　在《D Parser 之前：写一个简单的虚拟机》里，其中计算 1 到 100 之和的程序 add.bin，是使用十六进制编辑器直接编辑出来的。虚拟机制作完后，考虑了一下，如果直接写 Z 的编译器，难度还是不小，所以决定，先写一个汇编语言的编译器，实现从汇编代码到机器代码的编译工作。

　　大体来说，汇编编译基本上是一条一条对照生成，不过，行号的需求使得其中多了一些复杂性，另外，我还决定加入注释的支持。所以，这也是一个比较好的机会实践一下分析器生成器的使用。

　　汇编语言部分做了少量修改，over 改为 end，行号改为加 @ 前缀，完成的 Grammatica 的分析文件如下：

%header%

GRAMMARTYPE = "LL"

DESCRIPTION = "A asm grammar for zvm."

AUTHOR      = "Lephone Liang"
VERSION     = "1.0"
DATE        = "7 January 2008"

LICENSE     = "."

COPYRIGHT   = "Copyright (c) 2008 Lephone. All rights reserved."


%tokens%

EAX                          = "eax"
EBX                          = "ebx"
ESP                          = "esp"
EIP                          = "eip"

SET                          = "set"
MOV                          = "mov"
TJMP                         = "jmp"
ADD                          = "add"
TGT                          = "gt"
TGTEQ                        = "gteq"
TEQ                          = "eq"
TNOT                         = "not"
IF                           = "if"
TOUT                         = "out"
TEND                         = "end"
POINT                        = "*"
COMMA                        = ","


NUMBER                       = <<(-)?([0-9])+>>
LABEL                        = <<@[a-z]+>>
COMMENT                      = <<;[^\n\r]*[\r\n]>> %ignore%
WHITESPACE                   = <<[ \t\n\r]+>> %ignore%


%productions%

Expression = Atom [Expression];

Atom
 = SetEax
 | MovEax8Esp
 | SetEbx
 | MovEbx8Esp
 | Mov8EspEax
 | Mov8EspEbx
 | AddEsp
 | AddEaxEbx
 | Gt
 | Gteq
 | Eq
 | Not
 | IfEaxJmp
 | Jmp
 | Out
 | End
 | LineLabel ;

SetEax            = SET EAX COMMA NUMBER;
MovEax8Esp        = MOV EAX COMMA POINT ESP;
SetEbx            = SET EBX COMMA NUMBER;
MovEbx8Esp        = MOV EBX COMMA POINT ESP;
Mov8EspEax        = MOV POINT ESP COMMA EAX;
Mov8EspEbx        = MOV POINT ESP COMMA EBX;
AddEsp            = ADD ESP COMMA NUMBER;
AddEaxEbx         = ADD EAX COMMA EBX;
Gt                = TGT;
Gteq              = TGTEQ;
Eq                = TEQ;
Not               = TNOT;
IfEaxJmp          = IF EAX TJMP LABEL;
Jmp               = TJMP LABEL;
Out               = TOUT EAX;
End               = TEND;
LineLabel         = LABEL;

　　生成代码后，加入新建的 ZasmC 工程，参照 Grammatica 的例子调试了一会儿，增加一些处理代码后，编译器可以正常工作了。用它编译上一次的的 1 到 100 和的汇编代码，发现几个汇编代码的格式错误 后，编译成功，加载入虚拟机，运行得到结果：5050。

　　还想再写一个程序验证一下，Fibonacci 序列是一个不错的例子，于是编写 d 的原型如下：

import std.stdio;

static void main(char[][] args)
{
 int i=0;
 int a=1;
 write(a);
 int b=1;
 write(b);
 int t;
 next:
 t = a + b;
 write(t);
 a = b;
 b = t;
 i++;
 if(i<10) goto next;
}

void write(int n)
{
 writefln("%d", n);
}

　　改写为汇编代码如下：

; 斐波那契
; esp i, esp+4 a, esp+8 b, esp+12 t
; int i=0;
set eax, 0
mov *esp, eax
; int a=1;
; write(a);
set eax, 1
add esp, 4  ; a
mov *esp, eax
out eax
; int b=1;
; write(b);
add esp, 4  ; b
mov *esp, eax
out eax
add esp, -8  ; i
; int t;
@next
; t = a + b;
; write(t);
add esp, 4  ; a
mov eax, *esp
add esp, 4  ; b
mov ebx, *esp
add eax, ebx
add esp, 4  ; t
mov *esp, eax
out eax
; a = b;
; b = t;
add esp, -4  ; b
mov eax, *esp
add esp, -4  ; a
mov *esp, eax
add esp, 8  ; t
mov eax, *esp
add esp, -4  ; b
mov *esp, eax
; i++;
add esp, -8  ; i
mov eax, *esp
set ebx, 1
add eax, ebx
mov *esp, eax
set ebx, 10  ; 循环次数
gteq
not
if eax jmp @next
end

　　用 ZasmC 编译，生成 Fibonacci.bin，加载到虚拟机，第一次运行错误，后来发现是 d 转汇编的时候的疏忽，修正汇编代码后，编译，加载运行，得到正确的结果。

　　下一步就是写 Z 的编译器了，这一步可能要花比较长的时间，准备把 Z 编译成汇编代码，然后再用这个汇编编译器编译成机器代码，这样，Z 编译器就不需要处理行号问题了。

　　下面是虚拟机和汇编编译器的源代码，以及运行 Fibonacci 的截图：

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

　　最近写了一点儿 D 程序，除了感觉标准库太差之外，没有一个好的 IDE 也是一个很头疼的事，特别是没有智能提示，每次调用一个函数什么的，都要查文档或者直接看源代码，实在是太费劲了。

　　所以决定自己尝试写一个支持智能提示的 D 的 IDE。因为 SharpDelelop 比较小，而且它对 C# 的支持也做到了智能提示、窗体编辑器等等，所以决定用它作为主框架，除了智能提示，也许还能加入 DFL 的窗体编辑之类的功能（Entice 做的窗体编辑已经不错了，只是没有事件支持）。目前，已经完成了语法加亮，代码折叠（目前和 notepad++ 一样只是通过大括号匹配来做的），下一步，就是智能提示了，而智能提示就牵涉到语法分析。

　　找了几个分析器生成器，试用之后，觉得 Grammatica 还不错，生成的代码比较清晰，调试起来也比较方便。照它的例子写了一个四则运算的分析器，还不错。

　　看了一下 D 的语法详细列表，那也不是一般的复杂。所以，决定先写一个简单的语言的分析器、编译器和虚拟机练练手。今天先把虚拟机做了出来。

　　这种语言的语法非常简单，姑且称之为 Z 语言吧（还没有细化）：

声明语句： int x;        // 只支持 int
赋值语句： x = 1;
条件语句： if(x > 1) { ... } else { ... }
跳转语句： goto lable
标签语句： :lable
输出语句： write(x);        // 只支持 int
注释语句： // ... <eol>

　　而虚拟机部分，参照 x86 asm，定义如下：

寄存器：        EAX, EBX, ESP, EIP        // EAX,EBX操作数，ESP堆栈指针，EIP指令指针
内存：          200000B，0B～99999B为堆栈，100000B～199999B为程序
指令：
      为EAX赋值：                       set eax, 1                // 01 01 00 00 00
        将当前堆栈地址变量复制到eax：     mov eax, *esp             // 02
        为EAX赋值：                       set ebx, 1                // 03 01 00 00 00
        将当前堆栈地址变量复制到ebx：     mov ebx, *esp             // 04
        为当前堆栈地址变量赋值eax：       mov *esp, eax             // 05
        为当前堆栈地址变量赋值ebx：       mov *esp, ebx             // 06
        esp 加运算：                      add esp, 1                // 07 01 00 00 00
        eax 加运算：                      add eax, ebx              // 08
        eax大于ebx？结果放eax：           gt                        // 11
        eax大于等于ebx？结果放eax：       gteq                      // 12
        eax等于ebx？结果放eax：           eq                        // 13
        eax bool not：                    not                       // 14
        eax 为非 0 跳转（相对）：         if eax jmp {sp}           // 21 {sp}
        无条件跳转（相对）：              jmb {sp}                  // 22 {sp}
        输出 eax：                        out                       // 31
        结束：                            over                      // ff

 　　另外，虚拟机需要能显示寄存器值，显示当前堆栈顶值，显示输出。支持单步执行。

　　再写一段小程序，用来验证虚拟机的运行情况，因为只支持 int，所以计算 1 到 100 的和是一个比较合适的小代码段， C 的代码如下：

int n = 0;
for(int i=1; i<=100; i++)
{
    n += i;
}
write(n);

　　Z 语言不支持 for 循环，所以，相应的 Z 代码大体如下：

int n = 0;
int i = 1;
:next
if(i > 100) { goto end; }
n += i;
i++;
goto next;
:end
write(n);

　　而根据上面定义的指令集，其相应的汇编代码如下：

// esp n, esp+4 i;
// int n = 0;
set eax, 0                               // 01 00 00 00 00
mov *esp, eax                            // 05
// int i = 1;
add esp, 4                               // 07 04 00 00 00
set eax, 1                               // 01 01 00 00 00
mov *esp, eax                            // 05
// :next
// if(i > 100) { goto end; }
mov eax, *esp                            // 02
set ebx, 100                             // 03 64 00 00 00
gt                                       // 11
if eax jmb <end>                         // 21 1B 00 00 00
// n += i;
mov ebx *esp                             // 04
add esp, -4                              // 07 FC FF FF FF
 mov eax *esp                             // 02
add eax, ebx                             // 08
mov *esp, eax                            // 05
add esp, 4                               // 07 04 00 00 00
// i++;
mov eax, *esp                            // 02
set ebx, 1                               // 03 01 00 00 00
add eax, ebx                             // 08
mov *esp, eax                            // 05
// goto next;
jmb <next>                               // 22 D9 FF FF FF
// :end
// write(n);
add esp, -4                              // 07 FC FF FF FF
mov eax, *esp                            // 02
out                                      // 31
over                                     // FF

　　虚拟机的代码不算复杂，VM 类拥有 eax, ebx, esp, eip 等属性，然后有一个函数 Step 提供执行一条指令的功能，在 Step 中，使用一个 switch 来处理不同的指令。之后，运行程序，把上面的汇编代码的字节序列写入 add.bin 文件中，用虚拟机加载，运行，得到结果：5050。

　　在把 Z 转换到汇编的过程中，发现写编译器的话，对于寄存器的使用，是一个很需要考虑的问题，而对于 D 智能提示，只需要分析器就够了，似乎写编译器有一些超出了，不过，既然都写了，就试着先把这个完成吧。

　　下面是源代码和运行截图：

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

　　本软件用于将文本的字符串转换为 Text、Default、Unicode、UTF-8 之间的互相转换，用于文本查询。转换结果使用十六进制表示。

　　D 语言版不需要特殊的运行库支持。相对于 VB5 版增加了允许输入十六进制的功能，相对于 .net 版减少了一些功能。

　　对于我自己来说，这是练习使用 D 语言的一个副产品。

　　程序使用 D 1.015, phobos 和 dfl 开发。

　　在这一次练习中，发现 D 语言使用上可以和 c# 很类似，比如我写的 HexStringCoding 类，从 c# 复制过来，只修改了几个小地方（如增加 cast，去除 unsafe），就可以正常编译并且正常运行。另外，和 c/dll 的集成也不错，使用 WideCharToMultiByte 之类的系统函数还是很方便的。dfl 大体模仿 .net，所以使用起来很方便。

　　不过，问题也不少。

　　比如 bool 类型可以和任何可以转换为 0 和 1 的值进行隐式转换，就是一个语言方面的缺陷。

　　另外，D 语言选择 char[] 当作字符串来处理，也是一个非常不可理解的事情。char[] 被定义为 utf8，所以如果要对它进行随机检索的话，就需要更多的代码和更差的运行效率，在我看来，utf8 根本不适合作为程序内部处理字符串的编码方案。utf16 才适合。另外，没有 string 类，而用数组来代替 string 的做法也问题多多，除了强类型检测之外，string 类还应该提供相应的字符串处理函数，而不是使用全局函数处理字符串。在我做这个程序的时候，是都使用 utf16 的 wchar[] 来做中间的字符串代替品的，不过，dfl 遵循使用 char[] 的方案，所以，和界面交互的部分也做了转换处理。也许以后可以修改一下 dfl 的代码，使之直接使用 utf16 吧。

　　另一个问题是，无法使用 obj == null 来判断一个实例是否为空，这个问题不知道别人有没有遇到，或者有什么别的解决方案，我是通过 try catch 的方式处理了，不过感觉很不爽。

　　另外，还遇到一个问题，基类定义了 abstract 的函数，子类实现了，但是没有使用 override 关键字，编译通过，但是运行结果莫名其妙，加上 override 之后就正常了。这个问题可能造成错误的几率要比上面说的问题大的多，本来，D 应该在这种情况下编译出错才是。

　　再者，D 的 module 组织方式，感觉是在鼓励大家把所有的类写入一个文件中，实在不是一个好的方式。

　　对于 dfl，也稍微说一下，它使用了首字母小写的方式，在我看来，既然模仿 .net，就不如模仿个彻底，让大家把 .net 的程序复制过来后，做最少的修改就能编译运行才好 —— 所有首字母改成小写，也是一个不小的工程啊。

　　Tango 的安装步骤很罗嗦，我还没有试过，不过，嗯，回头还是应该试一下的。

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

　　原本，我听说 Partial Class 的时候，以为可以为已存在的类添加方法了，不过，Partial Class 只能在同一个 Assembly 之中的要求，使得它并不能实现这一点。.Net 3.5 增加了很多语言特性，扩展方法是其中一个。用扩展方法，我们就可以为已经存在的类添加方法。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

　　刚见到VS2008要在11月底发布的消息，有些反感，本来该出RC的时候，怎么就Release了？我都不急，微软急什么？

　　结果，还只是月中，VS2008就宣布发布，而且MSDN开始提供下载。而Scott的Blog上介绍的时候，还说，Silverlight 1.1的什么插件还没有能支持VS2008 Release版，需要额外的一周时间；这两天，又说本来预计上星期（和 VS2008 同时）发布的 VSS 2005 对于 VS2008 支持的兼容包因为临时发现一个BUG，所以推迟发布……

　　当年 VS2005 自带 SQL 2005 Express，既然明年二月也会出 SQL 2008，VS 2008 自然应该自带 SQL 2008 Express，结果只自带了一个 SqlCE 3.5，根本不是一码事嘛。别说存储过程，连语法都不同，要写 SQL Server 的程序还是需要用 SQL Server 2005。或者微软觉得 VS 本来就不该附带 Sql Server 吧。

　　不过，牢骚归牢骚，微软既然说这就是最终版，那么它就是，至于以后会不会有 VS 2008 SP1，那是后事了。

　　于是下载安装，正好看到 Scott 的文章说到我比较关心的 Team Explorer 2008 访问 TFS 2005 的事，说是完全没有问题，于是比较放心，安装后连接 CodePlex 试了一下，完全和以前一样，包括以前一个 TE 2005 留下的本地文件版本的 BUG 都保留了，不过基本上是个视觉系 BUG —— 碍眼不碍事，所以倒也没有什么问题。既然测试了在这一方面没有问题，也卸载了 VS 2005。

　　升级 DbEntry.Net 的时候，发现有两个项目没有设置 .Net Framework 版本，这个问题比较奇怪，不过，自己设置一下也就是了。编译，运行单元测试，完全通过，嗯，感觉还是不错滴。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

　　这是我设计的一个轻量级的 .Net ORM (Object Relational Mapping) 数据访问及 WEB 框架。对于 ORM 和 Sql 调用，它都拥有清晰和易用的接口，目前支持 SqlServer、SQLite、MySql、Access、Firebird、Oracle 等数据库。对于 WEB 开发，它既支持 ASP.NET 2.0 的 DataSource 方式，也支持 Ruby On Rails 风格的 MVC 方式。

　　目前，数据库部分已经支持多主键、多表联合查询、快速分页集合、隐式数据库事务、连贯API查询、ActiveRecord风格查询、动态对象、部分保存、自动创建数据表、一对一、一对多、多对多关系等功能，具体实现请参阅 Samples 中的例子程序和单元测试的内容。

　　而 DataSource 部分，因为绑定数据访问组件，所以可以只需要修改配置文件，不需要修改任何代码的在不同的数据库之间切换。另外，还支持按命名约定的方式绑定“新建”和“编辑”页面的控件，以最少的代码完成输入、验证、保存等一系列操作。

　　Rails 风格的 MVC 框架目前已经完成 MVC 部分，脚手架，基类中的 LinkTo、UrlTo 等快捷函数，Http Get 支持等。目前脚手架部分没有数据验证模块，不过，自己写的 MVC 代码可以自行实现验证。

　　例子程序访问的数据库主要是 Access，而单元测试使用的数据库是 SQLite，通过修改配置文件中数据源部分，可以使之不需要重新编译即可工作于其它数据库上。配置部分通过 App.config 进行，请参阅 Samples 中的例子程序中的 App.config 和 UnitTest 项目内嵌的配置文件 UnitTest.config.xml 。

　　我在 MS Sql Server 2000、MS Sql Server 2005 Express、 MS Access 2003、MySql 5.0、SQLite 3、Firebird 2.0.3 和 Oracle 10g Express 上测试过本组件。

　　v0.33 版比较大的改变为：
　　·支持移除一对多、多对多关系
　　·支持 Firebird、Oracle
　　·增加缓存系统
　　·支持 SoftDelete、CreatedOn、UpdatedOn
　　·支持 ASP.NET 2.0 Membership 系统
　　·DataSource 支持“新建”和“编辑”页面
　　·Rails 风格 MVC 框架

　　数据访问部分简单的使用方法如下：

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

刚在 C++ 博客上看到一篇中文编程的小文，逗到我了，摘录一段：

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

　　在 玩了一会儿 SQL Server Compact 3.5 里，我说，因为 SQL Server Compact 3.5 因为连 TOP 都不支持，所以会很慢。不过，这两天想了一下，可能是我小题大作了。

　　其实在数据库内部，应该是不论使用 TOP 与否，第一次查询都要进行的，而只要我们不进行读取，就和数据库没有返回它差不多，那么有没有 TOP 的关系应该倒是不大。

　　另外，对于像 SQL Compact 这样的文件型数据库来说，所谓的驱动程序就是一个动态链接库，也就是所有的操作都是在同一个进程中的，所以移动游标的开销也很小，差别只是在于，是我们来执行跳过前面这些记录的工作，还是驱动程序来做。没有起始定位符，对于速度的影响也不会太大吧。

　　所以，还好。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师