as2解析json

as2写的json解析，带容错，如果要做格式检查，得自己修改了，直接贴代码

//--------------------------------------------------json解析----------------------------------------------------------
class Json extends Object{
    public static var pos:Number=0;
    
    private static function isDigit( ch:String ):Boolean
    {
            return ( ch >= '0' && ch <= '9' )||( ch == "+" )||( ch == "-" )||( ch == "." );
    }
    
    private static function isHexDigit( ch:String ):Boolean
    {
            return ( isDigit( ch ) || ( ch >= 'A' && ch <= 'F' ) || ( ch >= 'a' && ch <= 'f' ) );
    }
        
    private static function toTrue(str:String, from:Number,to:Number)
    {
        pos=from+3;
        return true;
    }
    
    private static function toFalse(str:String, from:Number, to:Number)
    {
        pos=from+4;
        return false;
    }
    
    private static function toNull(str:String, from:Number, to:Number)
    {
        pos=from+3;
        return null;
    }
    
    private static function toNAN(str:String, from:Number, to:Number)
    {
        pos=from+2;
        return Number.NaN;
    }
    private static function toNumber(str:String, from:Number, to:Number)
    {
        var i:Number = from+1;
        while(i<=to)
        {
            var c = str.charAt(i);
            if(!isDigit(c))
                break
            i++;
        }
        var num:Number = Number(str.substring(from, i))
        if(!isFinite(num))
            throw{msg:"json格式错误，不正确的数字, 错误位置:"+from};
        pos=i-1;
        return num;
    }
    
    public static function unescapeString( str:String ):String
    {
        var pos:Number = 0;
        var result="";
        while(pos<str.length)
        {
            var c:String=str.charAt(pos);
            if(c=="\\"){
                if((pos+5<str.length) && str.charAt(pos+1)=="u")
                {
                    var hexValue:String = "";
                    for ( var i:Number = pos+2; i < pos + 6; i++ )
                    {
                        var c:String = str.charAt( i );
                        if ( !isHexDigit( c ) )
                        {
                            throw{msg:"json格式错误，字符串unicode编码转换错误，错误位置:"+i};
                        }
                        hexValue += c;
                    }
                    result += String.fromCharCode( parseInt( hexValue, 16 ) );
                    pos=pos+5;
                }else{
                    result=result+c;
                }
            }else{
                result=result+c;
            }
            pos=pos+1;
        }
        return result;
    }
    
    private static function toStr(str:String, from:Number,    to:Number)
    {
        var ignor:Boolean = false
        for(var i:Number = from+1; i<=to; i++)
        {
            var c:String=str.charAt(i);
            if(!ignor)
            {
                if(c=="\"")
                {
                    pos=i;
                    return unescapeString(str.substring(from+1, i));
                    //return str.substring(from+1, i);
                }else if(c=="\\")
                    ignor=true;
            }else{
                ignor=false;
            }
        }
        
        throw{msg:'json格式错误，字符串没有找到结尾, 错误位置:'+from};
    }
    
    private static function toArray(str:String, from:Number, to:Number)
    {
        var arr:Array = [];
        pos=from+1;
        while(pos<=to)
        {
            var c:String = str.charAt(pos);
            switch(c)
            {
                case "\"":
                    arr.push(toStr(str, pos, to));
                    break;
                case  "[":
                    arr.push(toArray(str, pos, to));
                    break;
                case "{":
                    arr.push(toObject(str, pos, to));
                    break;
                case "]":
                    return arr;
                case "f":
                    arr.push(toFalse(str, pos, to));
                    break;
                case "F":
                    arr.push(toFalse(str, pos, to));
                    break;
                case "t":
                    arr.push(toTrue(str, pos, to));
                    break;
                case "T":
                    arr.push(toTrue(str, pos, to));
                    break;
                case "n":
                    arr.push(toNull(str, pos, to));
                    break;
                case "N":
                    arr.push(toNAN(str, pos, to));
                    break;
                default:
                    if(isDigit(c))
                        arr.push(toNumber(str, pos, to));
            }
            pos=pos+1;
        }
        throw{msg: 'json格式错误，表没有找到结尾, 错误位置:'+from};
    }
    
    private static function toObject(str:String, from:Number,    to:Number)
    {
        var obj:Object = {};
        var key;
        pos=from+1;
        while(pos<=to)
        {
            var c:String = str.charAt(pos);
            switch(c)
            {
                case "\"":
                    if(!key)
                    {
                        key=toStr(str, pos, to);
                    }else{
                        obj[key] = toStr(str,pos,to);
                        key = null;
                    }
                    break;
                case  "[":
                    if(!key){
                        key=toArray(str, pos, to);
                    }else{
                        obj[key]=toArray(str, pos, to);
                        key=null;
                    }
                    break;
                case "{":
                    if(!key){
                        key=toObject(str, pos, to);
                    }else{
                        obj[key]=toObject(str, pos, to);
                        key=null;
                    }
                    break;
                case "}":
                    return obj;
                case "]":
                    return obj;
                case "f":
                    if(!key)
                        throw{msg:"json格式错误，boolean不能做key, 错误位置:"+from};
                    obj[key]=toFalse(str, pos, to);
                    break;
                case "F":
                    if(!key)
                        throw{msg:"json格式错误，boolean不能做key, 错误位置:"+from};
                    obj[key]=toFalse(str, pos, to);
                    break;
                case "t":
                    if(!key)
                        throw{msg:"json格式错误，boolean不能做key, 错误位置:"+from};
                    obj[key]=toTrue(str, pos, to);
                case "T":
                    if(!key)
                        throw{msg:"json格式错误，boolean不能做key, 错误位置:"+from};
                    obj[key]=toTrue(str, pos, to);
                    break;
                case "n":
                    if(!key)
                        throw{msg:"json格式错误，null不能做key, 错误位置:"+from};
                    obj[key]=toNull(str, pos, to);
                    break;
                case "N":
                    if(!key)
                        throw{msg:"json格式错误，nan不能做key, 错误位置:"+from};
                    obj[key]=toNAN(str, pos, to);
                    break;
                default:
                    if(isDigit(c)){
                        if(!key){
                            key=toNumber(str, pos, to);
                        }else{
                            obj[key]=toNumber(str, pos, to);
                            key=null;
                        }
                    }
            }
            pos = pos + 1
        }
        throw{msg:'json格式错误，表没有找到结尾, 错误位置:}'+from};
    }
    
    public static function decode(str:String)
    {
        pos=0;
        if(str=="")
            return null;
        var c=str.charAt(pos);
        switch(c)
        {
            case "\"":
                return toStr(str, pos, str.length-1);
            case "[":
                return toArray(str, pos, str.length-1);
            case "{":
                return toObject(str, pos, str.length-1);
            case "f":
                return false;
            case "F":
                return false;
            case "t":
                return true;
            case "n":
                return null;
            case "N":
                return Number.NaN;
            case "T":
                return true;
            default:
                if(isDigit(c))
                    return toNumber(str, pos, str.length-1);
        }
    }
}