详细的发布公告：
http://www.dsource.org/projects/tango/wiki/0_99_7_release
最要紧的改进莫过于添加了新的 container 包了，不知是 tango.util.container 还是 tango.util.collection？

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

从上一篇继续

首先还是需要创建Sprite和Frame  animationImage是图像路径（char[]）

animationFrame = new Frame(Texture(animationImage), Rect(70,496,70,124));

Rect的四个参数（起始点X坐标，起始点Y坐标，宽度，高度）单位：像素

private LinearAnimation animation;
animation = new LinearAnimation(animationFrame, 4, 200, LinearAnimation.Direction.ForwardLoop);

LinearAnimation四个参数（图像，动画帧数，播放速度，播放方式）

把创建的动画链接到精灵  播放它

sprite.addChild(animation.start());

动画基本就是这样子

另外如果只需要绘制静态图像  不进行复杂运算  可以直接写

drawImage(Texture(image), Point(200,200), Size(400,400), Point(0,0), 0, Color.White);

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

[system]
//log format
Format=NCSA
//log of the dat
FileName=D:\temp\today.log
//port
Listen_Port=8000
//server IP
IP=127.0.0.1
//server port
Server_port=9000
//time interval (in SECs)
Time_Interval=20

2008-03-31 00:00:19 10.11.14.56 - 10.11.1.9 80 GET /acip/shownewsh.asp - 200 Mozilla/4.0+(compatible;+MSIE+6.0;+Windows+NT+5.1;+SV1)
2008-03-31 00:00:20 10.11.14.56 - 10.11.1.9 80 GET /acip/images/Delighting+you+always+(Red)+789x382.gif - 304 Mozilla/4.0+(compatible;+MSIE+6.0;+Windows+NT+5.1;+SV1)
2008-03-31 00:00:47 10.11.10.81 - 10.11.1.9 80 GET /acip/shownewsh.asp - 200 Mozilla/4.0+(compatible;+MSIE+6.0;+Windows+NT+5.0)
2008-03-31 00:01:31 10.11.50.67 - 10.11.1.9 80 GET /acip/shownewsh.asp - 200 Mozilla/4.0+(compatible;+MSIE+6.0;+Windows+NT+5.1;+SV1)
2008-03-31 00:01:36 10.11.46.90 - 10.11.1.9 80 GET /acip/shownewsh.asp - 200 Mozilla/4.0+(compatible;+MSIE+6.0;+Windows+NT+5.1;+SV1)
2008-03-31 00:01:38 10.11.44.64 - 10.11.1.9 80 GET /eis/Report/Executive+Information+System - 404 Mozilla/4.0+(compatible;+MSIE+6.0;+Windows+NT+5.0)

char[char[]] config; // 配置参数

RegExp commentPattern = RegExp(r"^//.*");
RegExp sectionPattern = RegExp(r"^\[[^\]]+\]");
RegExp keyValuePattern = RegExp(r"(.+)=(.+)");

char[][] source; // 源log的数据

void Delay(int clicks)
{
unsigned int far *clock=(unsigned int far *)0x0000046CL;
unsigned int now;
now=*clock;
while(abs(*clock-now)<clicks){}
}

import std.conv;
import std.date;
import std.file;
import std.path;
// import std.random; // for rand()
import std.regexp;
import std.stdio;
import std.string;

import std.c.stdlib;
import std.c.time;

static const char[] CONFIG_FILENAME = "./RT_Config.inc";
static const char[] LOG_SOURCE_FILENAME = "./record.log";
static const int FOREVER = -1;

char[][char[]] config; // configuration data
int timeInterval;      // time interval
char[] logFileName;    // destination log file's name
char[][] source;       // source log contents

// Load the configuration data,
// and set time interval/destination filename
bool loadConfig() {
    char[] file = cast(char[])read(CONFIG_FILENAME);
    if(file == null) return false;
    char[][] lines = splitlines(file);

    RegExp commentPattern = RegExp(r"^//.*");
    RegExp sectionPattern = RegExp(r"^\[[^\]]+\]");
    RegExp keyValuePattern = RegExp(r"(.+)=(.+)");
    foreach (char[] line; lines) {
        if (commentPattern.test(line)) continue; // skip comments
        if (sectionPattern.test(line)) continue; // skip section tags
        if (keyValuePattern.test(line)) {
            config[toupper(keyValuePattern.match(1))] = keyValuePattern.match(2);
        }
    }

    timeInterval = toInt(config["TIME_INTERVAL"]);
    logFileName = config["FILENAME"];

    return true;
}

// Load the source log contents
bool loadSource() {
    char[] file = cast(char[])read(LOG_SOURCE_FILENAME);
    if(file == null) return false;
    source = splitlines(file);

    return true;
}

// get a random number in the range [min, max)
// min and max should be a positive integer
int random(int min, int max) {
    int rand = std.c.stdlib.random(20);
    while (rand < 5) rand = std.c.stdlib.random(20);
    return rand;
}

// get a string representation of the current system time
// in the format "YYYY-MM-DD hh:mm:ss"
char[] getCurrentTimeString() {
    d_time lNow = std.date.getUTCtime();
    return std.string.format("%04d-%02d-%02d "
             ~ std.date.toTimeString(lNow)[0..$-9],
               YearFromTime(lNow),
               MonthFromTime(lNow),
               DateFromTime(lNow));
}

// generate a line of dummy log
char[] getLogLine() {
    int rand = std.c.stdlib.random(source.length);
    return getCurrentTimeString() ~ source[rand][19..$];
}

// exit the program abnormally
void abort(char[] message) {
    writefln("Error: " ~ message);
    exit(1);
}

/*
// execute an action repeatly with specified time interval
// busy wait version
void repeat(void delegate() action, int interval, int limit) {
    if (action == null) return;
    if (interval < 0) return;

    time_t old = time(null);
    while (limit != 0) {
        time_t now = time(null);
        if (now >= old + interval) {
            old = now;
            action();
            --limit;
        }
    }
}
*/

// execute an action repeatly with specified time interval
// sleep-and-wait version
// TODO: fix the limit param...
void repeat(void delegate() action, int interval, int limit) {
    Timer timer = new Timer(interval, action, (limit < 0));
    timer.start();
    timer.wait();
}

// program entry point
void main(char[][] args) {
    // load configuration
    if (!loadConfig()) abort("invalid configuration file.");

    // load source log
    if (!loadSource()) abort("invalid source log file.");

    // append a few lines of log first
    int r = random(5, 20);
    // append generated log to destination
    for (int i = 0; i < r; ++i) {
        if (exists(logFileName) && isfile(logFileName)) {
            append(logFileName, newline ~ getLogLine());
        } else { // destinatin log file doesn't exist, create one
            // TODO: check and create directories on the path
            // write log's header comment
            write(logFileName,
                  "#Software: Microsoft Internet Information Services 5.0" ~ newline
                ~ "#Version: 1.0" ~ newline
                ~ "#Date: 2008-03-31 00:00:19" ~ newline
                ~ "#Fields: date time c-ip cs-username s-ip s-port cs-method"
                ~ " cs-uri-stem cs-uri-query sc-status cs(User-Agent)" ~ newline);
            // write first line of log content
            append(logFileName, getLogLine());
        }
    }

    // append new log to destination, in specified time interval
    repeat(delegate() {
        // get a random number in the range [5, 20)
        r = random(5, 20);
        // append generated log to destination
        for (int i = 0; i < r; ++i) {
            append(logFileName, newline ~ getLogLine());
        }
    }, timeInterval, FOREVER);
}

//===============================================================
// Timer, written by Dennis Kempin
//===============================================================

import std.thread;

version(Windows) {
    import std.c.windows.windows;
}

version(linux) {
    import std.c.linux.linux;
}

class Timer: Thread {
    private void delegate() action;
    private int waitTime;
    private bit autoRestart;

    this(int waitTime, void delegate() action, bit autoRestart=false) {
        this.action = action;
        this.waitTime = waitTime;
        this.autoRestart = autoRestart;
    }

    protected this(int waitTime, bit autoRestart=false) {
        this.waitTime = waitTime;
        this.autoRestart = autoRestart;
    }

    override int run() {
        sleep(waitTime);
        execute();
        while(autoRestart)
        {
            sleep(waitTime);
            execute();
        }
        return 0;
    }

    void execute() {
        action();
    }

    private void sleep(int time) {
        version(Windows) {
            Sleep(time*1000);
        }

        version(linux) {
            usleep(time*1000);
        }
    }
}

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

看了dsource上的Tank游戏源代码  基本了解代码结构  话说这arclib文档的更新速度实在是......不敢恭维


import arc.all;
import arc.scenegraph.all;
import arc.physics.all;
import arc.physics.shapes.all;

private Sprite sprite;
private Frame frame;
private Box box;
private char[] image = "image/arclib_logo.png";

int main(){
    //创建主窗口
    arc.window.open("Game", 600, 600, false);
    arc.input.open();
    //创建一个简单的精灵 严格说应该先创建world和worldTransform 我从简了
    frame = new Frame(Texture(image));
    box = new Box(frame.getFrame.getSize, 100);
    box.translation = Point(300,100);
    sprite = new Sprite(box,frame);
    //将精灵加入场景节点
    rootNode.addChild(sprite);
    //绘图
    arc.scenegraph.drawable.drawScenegraph();
    arc.window.swap();
    while (!arc.input.isQuit)
        {
            arc.window.clear();
            arc.input.process();
            arc.time.process();
        }
    arc.window.close();
    return 0;
}   

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

从去年开始关注起D  因为本人并不是程序员  所以唯一感兴趣的就是拿它做游戏  然后就看到了arclib  于是想装上试试  不过官网上的文档实在有点滞后  在配置上费了一些周折  我把这个过程写出来  希望对那些想要使用D和arclib的爱好者能够起到一点帮助：）

OS：windows XP SP2

需求：

DMD 1.027 & Tango Version 0.99.5

不要用其它版本 因为很可能无法正常编译

下载：http://www.dsource.org/projects/tango/wiki/0_99_5_DmdDownloads


首先确认dmd/dmc/dsss已加入环境变量

然后用dsss安装arclib  运行CMD  输入：

dsss net install arclib-core

有基于Phobos和 Tango的版本  但是用dsss下载的是Tango

然后自动安装编译 没提示出错就说明安装成功了

还要到http://www.dsource.org/projects/arclib/browser/downloads/dll 下载所有的DLL文件

否则程序无法编译  我就是被这个困挠了一段时间

现在arclib已经配置好了

随意建立一个D文件  输入以下代码：

module main;

import arc.all;

int main()
{
   arc.window.open("Hello World", 400,300,0);
   arc.input.open();
   Font f = new Font("font.ttf", 12);
   char[] text = "hello!";
   while (!arc.input.keyDown(ARC_QUIT))
   {
      arc.input.process();
      arc.window.clear();
      f.draw(text, Point(10,10), Color.Green);
      drawPixel(Point(10,10), Color.Green);
      arc.window.swap();
   }
   arc.window.close();
   return 0;
}

把刚下载的DLL全拷贝到源文件的目录下 还有不要忘了写dsss.conf文件（那个字体需要下载 也可以用其他字体代替）

然后dsss build  看到这个窗口画面就说明成功了

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

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

using System;
using System.Threading;
using System.Collections;
using System.Collections.Generic;
using System.Net.Sockets;
using System.Net;


namespace ConsoleApplication1
{
    public enum EventType
    {
        ReadEvent = 1,
        WriteEvent = 2
    }

    public class Event
    {
        private Socket sock;
        private EventType eventType;
        private IEnumerator<int> task;

        public Event(Socket sock, EventType eventType)
        {
            this.sock = sock;
            this.eventType = eventType;
        }

        public Socket getSocket()
        {
            return sock;
        }

        public EventType getEventType()
        {
            return eventType;
        }

        public void setTask(IEnumerator<int> task)
        {
            this.task = task;
        }

        public IEnumerator<int> getTask()
        {
            return task;
        }

        public void onEvent()
        {
            Console.WriteLine("onEvent");
            Scheduler.scheduleNow(task);
        }
    }

    public class ReadEvent : Event
    {
        public ReadEvent(Socket sock)
            :base(sock, EventType.ReadEvent)
        {
            
        }
    }

    public class WriteEvent : Event
    {
        public WriteEvent(Socket sock)
            : base(sock, EventType.WriteEvent)
        {
        }
    }

    class EventManager
    {
        private IDictionary<Socket, Event> readEvents = new Dictionary<Socket, Event>();
        private IDictionary<Socket, Event> writeEvents = new Dictionary<Socket, Event>();

        private IEnumerator<int> myTask = null;

        public int registerHandler(Event ev)
        {
            Console.WriteLine("registerHandler");
            if ((ev.getEventType() & EventType.ReadEvent) > 0)
            {
                readEvents.Add(ev.getSocket(), ev);
            }
            else
            {
                writeEvents.Add(ev.getSocket(), ev);
            }

            if (myTask == null)
                myTask = runLoop();


            Scheduler.scheduleNow(myTask);

            return 0;
        }

        public IEnumerator<int> runLoop()
        {
            Console.WriteLine("enter run");
            do
            {
                Console.WriteLine("run loop");
                yield return 1;

                IList rlist = new List<Socket>(readEvents.Keys);
                IList wlist = new List<Socket>(writeEvents.Keys);

                int timeoutMS = 1000000;
                if (Scheduler.hasEvents()) timeoutMS = 0;
                //Console.WriteLine("begin select: " + rlist.Count + ", " + wlist.Count);
                Socket.Select(rlist, wlist, null, timeoutMS);
                //Console.WriteLine("end select: " + rlist.Count + ", " + wlist.Count);

                Socket sock = null;
                Event ev = null;

                if (rlist.Count > 0)
                {
                    sock = (Socket)rlist[0];
                    readEvents.TryGetValue(sock, out ev);
                    readEvents.Remove(sock);
                }
                else if (wlist.Count > 0)
                {
                    sock = (Socket)wlist[0];
                    writeEvents.TryGetValue(sock, out ev);
                    writeEvents.Remove(sock);
                }

                if (ev != null)
                    ev.onEvent();
            } while (readEvents.Count != 0 || writeEvents.Count != 0);

            myTask = null;
        }
    }

    public static class Scheduler
    {
        public delegate IEnumerable<int> T();

        [ThreadStatic]
        private static IList<IEnumerator<int>> tasks = new List<IEnumerator<int>>();

        [ThreadStatic]
        private static EventManager eventManager = new EventManager();

        [ThreadStatic]
        private static Event lastEvent;

        public static bool hasEvents()
        {
            return tasks.Count > 0;
        }

        public static void spawn(T del)
        {
            var task = del().GetEnumerator();
            schedule(task);
        }

        public static void schedule(IEnumerator<int> task)
        {
            tasks.Remove(task);
            if (lastEvent != null)
                lastEvent.setTask(task);
            else
                tasks.Add(task);
            lastEvent = null;
        }

        public static void scheduleNow(IEnumerator<int> task)
        {
            tasks.Remove(task);
            tasks.Insert(0, task);
        }

        public static void remove(IEnumerator<int> task)
        {
            Console.WriteLine("remove task");
            tasks.Remove(task);
        }

        public static void run()
        {
            while (tasks.Count > 0)
            {
                IEnumerator<int> task = tasks[0];
                tasks.RemoveAt(0);
                bool ret = task.MoveNext();

                if (ret)
                    schedule(task);
            }
        }

        public static int registerAndWaitEvent(Event ev)
        {
            lastEvent = ev;
            return eventManager.registerHandler(ev);
        }
    }

    // 测试程序：

    class Program
    {
        public static IEnumerable<int> test(string id)
        {
            for (int i = 0; i < 5; i++)
            {
                System.Console.WriteLine("id: " + id + ", " +i);
                yield return i;
            }
        }

        public static IEnumerable<int> clientLoop(Socket client)
        {
            while (true)
            {
                Console.WriteLine("client loop");
                yield return Scheduler.registerAndWaitEvent(new ReadEvent(client));
                byte[] buffer = new byte[1024];
                int ret = client.Receive(buffer);
                if (ret > 0)
                {
                    //Console.WriteLine(buffer);
                    client.Send(buffer);
                }
                else
                {
                    client.Close();
                    break;
                }
            }
        }

        public static IEnumerable<int> serverLoop()
        {
            Socket sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            IPHostEntry IPHost = Dns.GetHostEntry("localhost"); 
            sock.Bind(new IPEndPoint(IPHost.AddressList[0], 23456));
            sock.Listen(128);
            while(true) {
                Console.WriteLine("server loop");
                yield return Scheduler.registerAndWaitEvent(new ReadEvent(sock));
                Console.WriteLine("accept event");
                Socket client = sock.Accept();
                Scheduler.spawn(() => clientLoop(client));
            }
        }

        static void Main(string[] args)
        {
            Scheduler.spawn(() => test("a"));
            Scheduler.spawn(() => test("b"));
            Scheduler.spawn(() => serverLoop());
            Scheduler.run();
        }
    }
}

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

import std.stdio;
import std.traits;

//检测整数操作溢出，不过对性能的影响比较大，lazy 关键字的标准运用。
Integral checked(Integral)(lazy Integral dg)
{
     static assert(isIntegral!(Integral));

     Integral result = dg(); //这里才对委托 dg 里的表达式求值
     asm {
         jo overflow;
     }
     return result;

     overflow:
     throw new Exception("Integer overflow occured");
}

int main()
{
     int t = int.max;
     try
     {
         int s = checked(t + 1);
         writefln("Result is %d", s);
     }
     catch(Exception e)
     {
         writefln("Whoops! %s", e.toString());
     }
     return 0;
}

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

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

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

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

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

wchar[] a2w( char[] a ) 
{
	return toUTF16(a); 
} 

char[] wcs2mbz(wchar[] ws)    
{    
    uint codepage =  1; //2000/+    
    char[] rz;     
    rz.length = WideCharToMultiByte(codepage, 0, ws.ptr, ws.length, null, 0, null, null) + 1;    
    WideCharToMultiByte(codepage, 0, ws.ptr, ws.length, rz.ptr, rz.length, null, null);    
    rz[rz.length-1] = 0;    
    rz.length = rz.length-1;    
    return rz;    
}    

char[] uc2cz(char[] a)
{
	return wcs2mbz(a2w(a));
}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘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++工程师

//日期格式为数字 如 20080901
//By zsp007@gmail.com

///验证是否是有效日期
bool date_validate(T)(T date)
{
   static T daysOfMonth[] = [0,31,28,31,30,31,30,31,31,30,31,30,31];

   T monthDay = date % 10000;
   if(monthDay > 1231)
      return false;
   if(monthDay == 229)
   {
      int year = date / 10000;
      if((year % 4) != 0)
          return false;
      return (!(year %100 == 0 && year % 400 != 0));
   }
   int month = monthDay / 100;
   int day = monthDay % 100;
   return (day > 0 && day <= daysOfMonth[month]);
}

///下一天
T tomorrow(T)(T i){
    static T daysOfMonth[] = [0,31,28,31,30,31,30,31,31,30,31,30,31];
    T day=i%100,month=(i/100)%100,year=i/10000;
    
    if(day>=daysOfMonth[month]){
        if(month==12){
            ++year;
            month=1;
            day=1;
        }else if(month==2&&day==28){
            if((year % 4)== 0){
                if(year%100 == 0 && year % 400 != 0){
                    goto add_month;
                }else ++day;
            }else goto add_month;
        }else{
        add_month:
            ++month;
            day=1;
        }
    }else ++day;
    return day+100*month+10000*year;
}

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

template eval( A... )
{
    const typeof(A[0]) eval = A[0];
}
char[] escape(char[] c){
    return "\""~c~"\"";
}
char[] column_def(char[] temp){
    return "typeof(this) " ~ temp ~ "(char[] v){ this.column[\"" ~ temp ~ "\"]=v;return this;}\n";
}

char[] table(char[] names)
{
    char[] table="char[][char[]] column;\n";
    char[] temp="";

    foreach (c;names){
        if(c==' '){
            table ~=column_def(temp);
            temp="";
        }else{
            temp~=c;
        }
    }
    if(temp!="")table~=column_def(temp);
    return table;
}

template Sql(char[] table_name,char[] column_list,char[] primary="id"){
   //TODO:assert primary in column_list

   mixin(table(column_list));

   typeof(this) opAssign(T)(T t){
        column=null;
        foreach(k,v;t)column[k]=v;
        return this;
   }
   char[] toString(){
       char[] result=table_name~"\n";
       foreach(k,v;column){
            result~="\t"~k~" = "~v~"\n";
       }
       return result;
   }
   char[] save(){
        if(primary in column)return update();
        else return insert();
   }
   
   char[] update(){
       assert(column[primary]!=null);
       char[] list="";
       foreach(k,v;column){
            if(k!=primary)
            list~=k~"="~escape(v)~",";
       }
       if(list!=""){
           list=list[0..$-1];
        }
       return "UPDATE "~table_name~" SET "~list~" WHERE "~primary~"="~escape(column[primary])~";";
      //UPDATE Person SET Address = 'Stien 12', City = 'Stavanger' WHERE LastName = 'Rasmussen'
   }
   char[] del(){
        assert(column[primary]!=null);
        return "DELETE FROM "~table_name~" WHERE "~primary~"="~escape(column[primary])~";";
   }
   char[] insert(){
       char[] key_list="";
       char[] value_list="";
       foreach(k,v;column){
            key_list~=k~",";
            value_list~=escape(v)~",";
       }
       if(key_list!=""){
           key_list=key_list[0..$-1];
           value_list=value_list[0..$-1];
        }
       return "INSERT INTO "~table_name~"("~key_list~") VALUES("~value_list~");";
       //INSERT INTO transcount_year(year, room_idx, dns_idx, redirip_id) VALUES(%d,%d,%d,%d);
   }

   static char[] where(char[] statement){
        return "SELECT * FROM "~table_name~" WHERE "~statement~";";
   }
   static char[] all(){
        return "SELECT * FROM "~table_name~";";
   }
}

class ErrDnameMonth{
   mixin Sql!("conf_err_dname_month","id month dname dns_query_count web_hit_count");
}
void main(){

    Cout(ErrDnameMonth.where("id=1")).newline.newline;

    auto month=new ErrDnameMonth;

    month
        .month("12")
        .dname("www.donews.net")
        .dns_query_count("23242");

    month.web_hit_count="124";

    Cout(month.toString).newline.newline;
    Cout(month.insert).newline.newline;
    Cout(month.all).newline.newline;
    Cout(month.save).newline.newline;
    
    
    MysqlMgr mysql_mgr_;//假设这是一个数据库封装
    Row[] rows;//取回的数据为字典格式
    mysql_mgr_ = new MysqlMgr();
    rows = mysql_mgr_.queryFetchAll(month.all);
    
    foreach(r;rows){
        auto em=new ErrDnameMonth;
        em=r;
        em.dns_query_count="23";
        oo.format("{}",em.update).newline.newline;
        oo.format("{}",em.del).newline.newline;
    }

    Cin.get();
}

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

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

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘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 智能提示，只需�