var Mysql = null;
 
function MysqlConnect() { //... }
 
MysqlSafeQuery = function(sql) {
    if (!Mysql || !Mysql.connection.writable) {
        MysqlConnect();
    }
 
    return Mysql.query(sql);
}

var Net = require('net');
var JsonStream = require('./JsonStream.js');
 
//创建一个普通的socket server
var server = Net.createServer(function(c) {
    //当有客户端连接后,socket连接之上创建一个JsonStream
    var stream = new JsonStream.Stream(c);
 
    //监听客户端发来的json数据
    stream.on('json', function(json) {
        console.log('receiv json from client:');
        console.log(json);
    });
 
    //没三秒钟向客户端发送一个json数据
    setInterval(function(){
        stream.write({
            data:'hello client',
            time:new Date()
        });
    }, 3000);
});
 
server.listen(7777);

var Net = require('net');
var JsonStream = require('./JsonStream.js');
 
//定义服务端支持的Rpc接口
var ServerApi = {
 
    //这是一个普通的接口,直接返回数据
    hello:function(name) {
        console.log('client call hello');
        return 'hello ' + name;
    },
 
    //这是一个异步返回的方法
    //这里的SimpleDeferred的确不是一个全功能的Deffered
    //只能用在异步返回的情况
 
    helloAfter:function(name, delay) {
        console.log('client call helloAfter');
        var defer = new JsonStream.SimpleDeferred();
        setTimeout(function(){
            defer.done('hello ' + name + ' after ' + delay + 's');
        }, delay * 1000);
        return defer;
    }
};
 
var server = Net.createServer(function(c) {
    var stream = new JsonStream.Stream(c);
    stream.delegate = ServerApi;
 
    //每3秒调用一次客户端的say方法
    setInterval(function(){
        stream.rpcCall('say', ['你好!']);
    }, 3000);
});
 
server.listen(7777);

stream.rpcCall('hello', ['client a'], function(res) {
     console.log(res);
});
 
stream.rpcCall('helloAfter', ['client a', 1], function(res) {
     console.log(res);
});

var Http = require('http');
var JsonStream = require('./JsonStream.js');
 
//Rpc接口定义
var ServerApi = {
};
 
//创建一个http server
var HttpServer = Http.createServer(function(request, response){
    //让JsonStream处理所有http请求
    JsonStream.HttpStream.acceptRequest(request, response);
});
 
JsonStream.HttpStream.events.on('new', function(stream, request) {
    console.log('new http stream !!!!!');
    stream.delegate = ServerApi;
    //发送json到浏览器端
    stream.write({
        data:'hello browser'
    });
});
 
HttpServer.listen(80);
//长连接的最大时长设为30秒
JsonStream.HttpStream.checkTimeOut(30);

;示例
$GENERATE 0-100000 push-$ IN A xx.xx.xx.xx

FLAGS="-DDEBUG"
 
define make-all
	gcc $(FLAGS) $1 -E -x c src/swfsocket.js -o $2/swfsocket.js 
	gcc $(FLAGS) $1 -E -x c src/swf/SwfSocket.rel.as -o src/swf/SwfSocket.as
	sed -i "/^#/d" $2/swfsocket.js
	sed -i "/^#/d" src/swf/SwfSocket.as
	cd src/swf; \
	mxmlc -static-link-runtime-shared-libraries -output=./SwfSocket.swf SwfSocketMain.as
	mv src/swf/SwfSocket.swf $2 
endef
 
main:
	$(call make-all,,bin)
	$(call make-all,-DSSL,bin_ssl)

function SSL_socket()
{
    alert('SSL');
}
 
function socket()
{
    alert('normal');
}

#include "header.js"
#ifdef _SSL
var socket = new SSL_socket();
#else
var socket = new socket();
#endif

.box {
  -moz-border-radius: 15px; /* Firefox */
  -webkit-border-radius: 15px; /* Safari and Chrome */
  border-radius: 15px; /* Opera 10.5+, future browsers, and now also Internet Explorer 6+ using IE-CSS3 */
 
  -moz-box-shadow: 10px 10px 20px #000; /* Firefox */
  -webkit-box-shadow: 10px 10px 20px #000; /* Safari and Chrome */
  box-shadow: 10px 10px 20px #000; /* Opera 10.5+, future browsers and IE6+ using IE-CSS3 */
 
  behavior: url(ie-css3.htc); /* This lets IE know to call the script on all elements which get the 'box' class */
}

el.innerHTML = '....';
if(window.update_css3_fix) update_css3_fix(el);

(function()
{
    if (!jQuery.browser.msie) return;
    jQuery.fn.__ohtml__ = jQuery.fn.html;
    jQuery.fn.html = function(value)
    {
        jQuery(this).__ohtml__(value);
        this.each(function()
        {
            update_css3_fix(this);
        });
        return this;
    };
})();

//计数加一
count ++
//更新ui
jQuery('#count').text(count);

this.data_bind('count', 'change', function(count)
{
    //更新计数
    jQuery('#count').text(count);
});
....
 
this.data_bind('count', 'change', function(count)
{
    //刷新分页
    refresh_pager(count);
});
 
this.set_data('count', this.get_data('count') + 1);

startloding();
new ajax({
    url : 'test.php',
    compete : function()
    {
         stoploading()
    },
    success : function(data)
    {
        try
        {
            var obj = json_decode(data);
        }
        catch(e)
        {
            //服务异常，未返回json造成异常
            error('服务器异常');
            return;
        }
 
        //正常的业务逻辑错误
        if ( json['code'] !== 0 )
        {
            error(json['desc']);
            return;
        }
 
        ...
    },
    error : function()
    {
        //网络请求失败造成异常
        error('网络异常');
    }
});

new action({
    action : 'load',
    action_name : '加载',
    url : 'test.php'
});
 
api.add_action('load_start', startloading);
api.add_action('load_complete', stoploading);
//这里的成功不是ajax成功，而是判定json['code']之后action真正的成功，这就要求所有action需要有统一的成功判定标准，和json包装格式
api.add_action('load_success', function(msg, data){  .... });
//这里没有添加异常处理，因为没有特殊需要，所以action会执行默认的错误处理，可能是一个弹窗

/**
 * 表单验证类
 * Author : emptyhua@gmail.com
 * Version : beta
 */
 
class FormValidator
{
    //所有验证函数定义时的前缀
    const PREFIX = 'form_validator_';
 
    //存储验证函数的出错信息
    public static $error_messages = array();
 
    //存储验证相关的数据
    protected $valid_rules = array(); 
 
    //存储上次验证的出错信息
    protected $errors = array();
 
    //是否完全检查
    protected $complete_check = true;
 
    public static function set_error($rule, $error)
    {
        self::$error_messages[$rule] = $error;
    }
 
    /**
     * 遇到第一个错误便返回
     */
 
    public function first_error_only()
    {
        $this->complete_check = false; 
    }
 
    /**
     * 执行所有验证规则,收集所有错误
     */
 
    public function show_all_errors()
    {
        $this->complete_check = true; 
    }
 
    /**
     * 设置验证规则
     * @param string $var 验证的变量名,例如 username
     * @param string $var_name 变量名的描述,例如 用户名
     * @param string $func_name 验证规则,可以是多个,并且可以传参,例如 require|length(9,12)
     * @param string $error_message 自定义的出错信息,可选,如果给定将覆盖验证函数的默认出错信息
     */
 
    public function set_rules($var, $var_name, $func_name, $error_message = NULL)
    {
        $data = array();
        $data['var_name'] = $var_name;
        $data['error'] = $error_message;
        $data['funcs'] = array();
        $funcs_with_arg = explode('|', $func_name);
        $args_match = array();
 
        //解析验证规则
        foreach( $funcs_with_arg as $func_with_arg )
        {
            preg_match('/\((.*)\)$/', $func_with_arg, $args_match);
            //规则函数是否携带参数
            if ( count($args_match) > 0 )
            {
                //参数列表
                $args = explode(',', $args_match[1]);
                //去掉参数后的验证规则名
                $func = str_replace('(' . $args_match[1] . ')', '', $func_with_arg);
                $data['funcs'][$func] = $args;
            }
            else
            {
                $data['funcs'][$func_with_arg] = NULL;
            }
        }
 
        $this->valid_rules[$var] = $data;
    }
 
    /**
     * 检验一组数据是否合法
     * @param array $data 一个关联数组
     * @return boolean
     */
 
    public function is_valid($data)
    {
        $this->errors = array();
        $valid = true;
        //遍历的顺序为规则添加的顺序
        foreach( $this->valid_rules as $var => $rule )
        {
            //判断数据中是否有此字段,没有的话置一个空的
            if (!isset($data[$var])) 
                $data[$var] = '';
 
            foreach($rule['funcs'] as $func => $args)
            {
                //真实的验证函数的名称,例如 form_validator_require
                $func_run = self::PREFIX . $func;
                //如果函数未定义,循环继续
                if ( !is_callable($func_run) ) continue;
 
                //为验证函数组装参数
                //顺序为:当前验证字段的值, 所有验证数据, 验证规则参数1, ...
                if ( $args === NULL ) 
                {
                    $args = array($data[$var], $data);
                }
                else
                {
                    array_unshift($args, $data);
                    array_unshift($args, $data[$var]);
                }
 
                //调用验证函数
                if ( !call_user_func_array($func_run, $args) )
                {
                    $valid = false;
                    //如果set_rules的时候没有自定义错误信息,则使用默认出错信息
                    if ( $rule['error'] === NULL )
                    {
                        //使用sprintf拼接错误信息
                        //参数顺序: 验证字段的描述, 验证函数的参数1, 验证函数的参数2 ...
 
                        //去掉刚才添加的字段值
                        array_shift($args);
                        //去掉刚才添加的所有验证数据
                        array_shift($args);
                        //添加字段名的描述
                        array_unshift($args, $rule['var_name']);
                        //添加默认的出错信息
                        array_unshift($args, self::$error_messages[$func]);
                        $this->errors[] = call_user_func_array('sprintf', $args);
                    }
                    else
                    {
                        //使用自定义错误信息
                        $this->errors[] = $rule['error'];
                        continue 2;
                    }
 
                    //如果设置不进行完全检查,则发现第一个错误后跳出最外层循环
                    if ( !$this->complete_check )
                    {
                        break 2; 
                    }
                }
            }
        }
 
        return $valid;
    }
 
    /**
     * 获取出错信息
     * @return string array
     */
 
    public function get_errors()
    {
        return $this->errors; 
    }
 
    /**
     * 返回第一条出错信息
     * @return string
     */
 
    public function get_first_error()
    {
        return $this->errors[0];
    }
 
}
 
//扩展验证规则很方便~
//设置规则的默认出错信息
FormValidator::set_error('require', '%s不能为空');
 
//定义验证函数,以FormValidator::PREFIX打头
function form_validator_require($str)
{
    return !(trim($str) == '');
}
 
FormValidator::set_error('equal', '重复输入不一致');
 
function form_validator_equal($str, $data, $eqto)
{
    if ( !isset($data[$eqto]) )
    {
        return false;
    }
 
    return $data[$eqto] == $str;
}

$vd = new FormValidator();
$vd->set_rules('p', '密码',  'require|length(9,12)');
$vd->set_rules('p2', '密码验证', 'equa(p)', '两次密码输入不一致');
if (!$vd->is_valid($_POST))
{
    var_dump($vd->get_errors());
}