aview-app 1.0.2

package/aardio/lib/protobuf/message.aardio

@@ -0,0 +1,348 @@
+//message 消息对象
+import protobuf.reader.inputString;
+import protobuf.type.scalar;
+import protobuf.type.enum;
+import protobuf.type.bytes;
+import protobuf.type.string;
+import protobuf.type.int32;
+import protobuf.type.int64;
+import protobuf.type.sint32;
+import protobuf.type.sint64;
+import protobuf.type.sfixed32;
+import protobuf.type.sfixed64;
+import protobuf.type.fixed32;
+import protobuf.type.fixed64;
+import protobuf.type.uint32;
+import protobuf.type.uint64;
+import protobuf.type.float;
+import protobuf.type.double;
+import protobuf.type.bool;
+import protobuf.type.map;
+import inet.http;
+import inet.url;
+
+namespace protobuf;
+ 
+class message {  
+	ctor( reader ) {
+		this.chunk = '';
+  		this.wiredType = wiredTypeLengthDelimited;
+  		this.reader = reader;
+  		 
+        this.value = this;  
+        this.fieldValues = {};
+        this.fieldNames = {};
+  		this.fieldTypes = {};
+  		this.fieldMapKeyValueType = {};
+  		this.fieldIsArray = {};
+		this.fieldIsPacked = {};
+		this.fieldOneOf = {};
+    };  
+    
+    _getFieldClass = function( index ){  
+    	var cls = eval( this.fieldTypes[ index ] )
+    	if(!cls)
+    		error( '\nWrong protobuf message class:' + this.fieldTypes[ index ] ,2)
+    	return cls;
+    };
+    
+    _createFieldObject = function( index,value ){
+    	var msg = this._getFieldClass( index )( this.reader );
+    	msg.keyValueType = this.fieldMapKeyValueType[index];
+    	
+    	if(value !== null) 	msg.value = value; 
+    	return msg;
+    };
+    
+    setFieldValue =  function (index, value) { 
+        if (value[["_isProtobufMessage"]]) {
+            this.fieldValues[index] = value;
+        }
+        else {
+            this.fieldValues[index] = this._createFieldObject(index,value); 
+        }
+        return  this.fieldValues[index];//return object;
+    };
+
+    getFieldValue = function (index) {
+    	var value = this.fieldValues[index];  
+    	if( value[["_isProtobufValueType"]] ) return value[["value"]]
+    		 
+        return value 
+    };
+
+	setFieldTime = function(index, value,format){
+		value.format = format;
+		return owner.setFieldValue( index,tostring(value) );
+	};
+	
+	getFieldTime = function(index,format){
+		var str = owner.getFieldValue(index)
+		return ..time(str,format);
+	};
+    
+	getFieldArray = function (index) {
+        return this.fieldValues[index] ; 
+    };
+    
+    setFieldArray = function (index,items) {  
+       this.fieldValues[index] = items; 
+    };
+    
+    getFieldArrayItem = function (index, key) {
+        var value = this.fieldValues[index][key];
+        if( value[["_isProtobufValueType"]] ) return value[["value"]]
+    		
+    	return value;
+    }; 
+
+    setFieldArrayItem = function ( index, index_arr, value) {
+    
+        if (value[["_isProtobufMessage"]]) {
+            this.fieldValues[index][index_arr]  = value;
+        }
+        else {
+            this.fieldValues[index][index_arr]  = this._createFieldObject(index,value); 
+        }
+        return  this.fieldValues[index][index_arr] ;//return object; 
+    }; 
+
+    getFieldArraySize = function (index) {
+        return #(this.fieldValues[index]);
+    };
+
+	encodeVarUint64 = function(n) { 
+		n = ..math.size64(n);
+		
+  		var s = {}
+  		var l,h = n.split32(); 
+  		while ( (l & ~0x7F) || h) {  
+    		s[#s+1] = (l & 0xFF) | 0x80;
+    		n = n.rshift(7); 
+    		l,h = n.split32();
+  		}
+  		
+  		s[#s+1] = l;
+  		return ..string.pack(s)
+	};
+	
+	getFieldTag = lambda(number) { 
+   		wiredType = number & 2#111;
+   		fieldNum = number >> 3;
+	};   
+	
+    serialize = function( rec = - 1) {
+        var str = '';
+        
+        if (rec > -1){
+            str ++= this.encodeVarUint64(rec << 3 | this.wiredType);
+        }
+		 
+        var stringinner = ''; 
+	    
+        for(index,field in this.fieldTypes ){
+        	 
+            var value = this.fieldValues[index]  
+            if ( this.fieldIsArray[index] ) { 
+            	
+            	if( this.fieldIsPacked[index]  ){
+            	    var fieldObject = this._createFieldObject(index); 
+            	     
+            	    var packedStr = '';
+            		for(i=1;#value;1){
+            		    if(value[i][["_isProtobufMessage"]]){
+            		    	packedStr = packedStr  ++ value[i].serialize(-1);  
+            		    }
+            		    else {
+            		    	fieldObject.value = value[i];
+                 	 		packedStr = packedStr  ++ fieldObject.serialize(-1);  
+            		    } 
+                	}  	
+                	
+                	stringinner = stringinner  ++ this.encodeVarUint64( index << 3 | wiredTypeLengthDelimited );
+                	stringinner = stringinner  ++ this.encodeVarUint64( # packedStr ); 
+                	stringinner = stringinner  ++ packedStr;
+            	}
+                else {
+                    var fieldObject = this._createFieldObject(index);  
+                    for(i=1;#value;1){
+                        if( value[i][["_isProtobufMessage"]] ){
+            		    	stringinner = stringinner  ++ value[i].serialize(index);  
+            		    }
+            		    else {
+            		    	fieldObject.value = value[i];
+                 	 		stringinner = stringinner  ++ fieldObject.serialize(index);  
+            		    }   
+                	}    
+                }
+            }
+            else if( value !== null )  { 
+                if (value[["_isProtobufMessage"]]) {
+            		 stringinner =  stringinner ++ value.serialize(index); 
+        		}
+        		else {
+            		 stringinner =  stringinner ++ this._createFieldObject(index,value).serialize(index); 
+        		}
+            }  
+        } 
+		
+        stringinner = stringinner ++ this.chunk;
+
+		if (this.wiredType == ..protobuf.message.wiredTypeLengthDelimited && rec > -1){ 
+            stringinner = this.encodeVarUint64(#stringinner) ++ stringinner;
+           
+        }  
+        return str ++ stringinner;
+    }; 
+
+    deserialize = function (){
+        this.chunk = ''; 
+        
+        var length = this.reader.nextUInt32();  
+        return this.deserializeAux(length);
+    };
+
+    deserializeAux = function ( length = 99999999 ) {
+    	var consume;
+    	var reader = this.reader
+        var _begin = reader.getPointer();
+      	
+        while (reader.getPointer() - _begin < length)  {
+            var oldpointer = reader.getPointer();
+            var next = reader.nextUInt32(); 
+              
+            if ( ! next )
+                break;
+                
+            var fieldTag = this.getFieldTag(next);   
+            
+            if (! this.fieldTypes[ fieldTag.fieldNum ] ) {
+            	 
+                if (fieldTag['wiredType'] == wiredTypeLengthDelimited ) {
+                    consume =..protobuf.type.string(reader);
+                }
+                else if (fieldTag['wiredType'] == wiredTypeVarint) {
+                    consume = ..protobuf.type.int32(reader);
+                }
+                else {
+                    error('I dont understand this wired code:' ++ fieldTag['wiredType'],3);
+                }
+
+                consume.deserialize();
+                this.chunk ++= reader.getMessageFrom(oldpointer);
+                continue;
+            }
+            
+            var fieldNum = fieldTag['fieldNum'];
+            var value = this.fieldValues[fieldNum];
+          	var msg =  this._createFieldObject( fieldNum ); 
+          	  
+            if (fieldTag['wiredType'] != msg.wiredType) { 
+          	
+                if(fieldTag['wiredType'] == wiredTypeLengthDelimited 
+                    && this.fieldIsArray[fieldNum]  && this.fieldIsArray[fieldNum]  ){
+                    
+                	var length = this.reader.nextUInt32();
+                	var _begin = reader.getPointer();
+                	
+                	var items = this.fieldValues[fieldNum];
+                	while (reader.getPointer() - _begin < length)  { 
+            			msg.deserialize() 
+            			
+            			if(msg[["_isProtobufValueType"]]){
+            			    ..table.push( items, msg.value ); 
+            			}
+            			else {
+            				..table.push( items, msg ); 
+            			}
+            			
+            			msg =  this._createFieldObject(  fieldNum ); 
+                	}
+                	
+                	continue;
+                }
+                else{
+            	 	error('\r\n' ++ 'Pb type:' 
+                    	++ fieldTag['wiredType'] 
+                    	++ '\r\n' ++ 'but message type ' 
+                    	++ msg.wiredType ++ '\r\n' ++ "message class:" ++ this.fieldTypes[fieldNum] );
+                }
+            }
+             
+            if(this.fieldOneOf[fieldNum]){
+                var oneof = this.fieldOneOf[fieldNum];
+                
+            	for(k,v in this.fieldOneOf){
+            		if(this.fieldOneOf[k] === oneof ){ 
+            			this.fieldValues[k] = null;
+            		} 
+            	} 
+            } 
+            
+            if ( this.fieldIsArray[fieldNum] ) {   
+            	msg.deserialize();
+            	
+            	if(k[["_isProtobufValueType"]]){
+                	..table.push( this.fieldValues[fieldNum] , msg.value); 
+                }
+                else {
+                	..table.push( this.fieldValues[fieldNum] , msg); 
+                }
+           
+            }
+            elseif ( this.fieldMapKeyValueType[fieldNum] ) {     
+                msg.value = this.fieldValues[fieldNum];
+                var k,v = msg.deserialize(); 
+            }
+            else {
+                this.fieldValues[fieldNum] = msg;  
+                msg.deserialize() 
+            } 
+        }
+        
+        return this;
+    };
+    
+	serializeToString = function(){
+		return this.serialize();
+	};
+	
+    parseFromString = function (message) {
+    	if(!#message)
+    		error("参数不能为空字符串",2) 
+ 		
+ 		for(k,v in this.fieldValues){ 
+ 			if( this.fieldIsArray[k]  ) this.fieldValues[k] = { @{_type="array"}};
+ 			elseif( this.fieldMapKeyValueType[k]  ) this.fieldValues[k] = {};
+ 		} 
+        this.reader = ..protobuf.reader.inputString(message);
+        this.deserializeAux();
+    };  
+    
+    tostring = function(){
+    	return this.serialize();
+    };
+    
+    fromString  = function(){
+    	return this.parseFromString();
+    };
+    
+    _isProtobufMessage = true; 
+} 
+
+
+namespace message { 
+	
+    wiredTypeVarint = 0;
+    wiredType64Bit = 1; 
+    wiredTypeLengthDelimited = 2;
+    wiredTypeString = 2;
+    wiredType32Bit = 5;
+}
+
+/**intellisense()
+protobuf = Protobuf 序列化协议,\n支持 proto2,proto3 语法。\n用法 请参考：aardio 范例 > 网络应用 > protobuf
+protobuf.message = Protobuf 消息对象，\nProtobuf 中所有类型都是继承自 protobuf.message。\n字段名中下划线后接小写字母会自动去掉下划线转换为驼峰式命名
+end intellisense**/
+
+ 

package/aardio/lib/protobuf/parser/_.aardio

@@ -0,0 +1,362 @@
+//parse 语法分析
+if(_STUDIO_INVOKED) import ide;
+
+import fsys;
+namespace protobuf;
+  
+class parser{ 
+	
+	ctor(){
+		this.subMessage = {}
+     	this.subEnum = {}
+     	this.oneof = {};
+     	this.name = "";	
+	}
+
+    parseFile = function (protofile,ns="",inProject ){
+        this.path = protofile;
+    	var str = ..string.load(protofile);
+        if(!str) error("打开 *.proto 文件失败:" + protofile,2);
+        
+        this.lex = ..protobuf.parser.lex(str); 
+        this.lex.protoPath = ..io.fullpath(protofile);
+     	this.lex.next();
+     	 
+     	this.nameSpace = ns;
+     	this.inProject = inProject;
+        this._parseMessage( this ); 
+        for(k,message in this.subMessage){
+            message.parseFullTypeName();
+        }
+        
+        this._createLib( inProject );
+    }
+    
+    parse = function (str,ns="",inProject=true){  
+     	this.lex = ..protobuf.parser.lex(str) 
+     	this.lex.next();
+     	 
+     	this.nameSpace = ns;
+     	this.inProject = inProject;
+        this._parseMessage( this ); 
+        for(k,message in this.subMessage){
+            message.parseFullTypeName();
+        }
+        
+        this._createLib( inProject );
+    }
+    
+    importFile = function(protofile,msgParent){
+    	var saveLex = this.lex;
+    	if(!saveLex.protoPath){
+    		error("只有自本地文件加载的 proto 文件才能使用 import 语句!",3)
+    	}
+    	
+    	protofile = ..fsys.path.full(protofile,..fsys.getParentDir(saveLex.protoPath));
+    	var str = ..string.load(protofile);
+        if(!str) error("导入 *.proto 文件失败:" + protofile,2)
+        
+    	this.lex = ..protobuf.parser.lex(str); 
+    	this.lex.protoPath = protofile;
+    	this.lex.next();
+    	
+    	this._parseMessage( msgParent ); 
+    	
+    	this.lex = saveLex;
+    }
+
+ 	_createLib = function(inProject){ 
+ 		var libDir = inProject ? ( _STUDIO_INVOKED ? ..ide.getProjectDir() ) : "\" 
+ 		libDir = ..fsys.joinpath( libDir,"lib\\");  
+ 		
+ 		for(k,message in this.subMessage){ 
+ 			var dir = ..io.fullpath( libDir ++ ..string.replace(message.nameSpace,"\.","\") )
+ 			..fsys.createDir(dir)
+ 			
+ 			var path = ..fsys.joinpath(dir,message.name + ".aardio")
+ 			
+ 			var code = message.serialize();
+ 			for(k,message in this.subMessage){
+ 				var ns =  ..protobuf.parser.message.combineNamespace(message.nameSpace,message.name );
+ 				
+ 				if( ..string.find(code,"@"".." + ns + '"') ){
+ 					code = "import " + ns + ';\r\n' + code;
+ 				}
+ 			}
+ 			
+ 			for(name,body in this.subEnum){
+ 				if( ..string.find(code,"@"".." + name + '"') ){
+ 					code = "import " + name + ';\r\n' + code;
+ 				}
+ 			}
+ 			
+ 			..string.save(path, (#message.nameSpace?("namespace "+message.nameSpace + ';\r\n'):"")
+ 				+ 'import protobuf.message;\r\nimport util.metaProperty;\r\n\r\n' + code )
+ 		} 
+ 		
+ 		var template = ..protobuf.parser.template;
+ 		for(name,body in this.subEnum){ 
+ 			 
+ 			var path = ..fsys.joinpath(libDir,name + ".aardio")
+ 			
+			var code = template.enum.format(
+				name = name;
+				body = body;
+			)
+			
+ 			..string.save(path, 'import protobuf.message;\r\nimport util.metaProperty;\r\n\r\n' + code )
+ 		} 
+ 		
+ 		if(_STUDIO_INVOKED) ..ide.refreshUserLib();
+ 	}
+ 	 
+    _parseMessage = function(  msgParent ) {
+    
+		var lex = this.lex;  
+ 
+        while ( lex.token ){
+            lex.checkKeyword()
+            if ( ..string.cmp( lex.data,'message') == 0 ) {
+            	lex.next();
+            	lex.checkKeyword()
+            	var nameMsg = lex.data;
+            	 
+            	var msg = ..protobuf.parser.message();
+            	msg.name = lex.data;
+            	msg.nameSpace = ..protobuf.parser.message.combineNamespace( msgParent.nameSpace,msgParent.name );
+            	msg.parent = msgParent; 
+            	msg.root = msgParent.root;
+            	
+            	msgParent.subMessage[ msg.name ] = msg;
+             
+             	lex.next(); 
+             	
+            	//lex.next();//exit 'message name'
+            	var beginLine = lex.line;
+            	lex.checkNext('{'#) 
+            	 
+            	if(lex.token != '}'#){ 
+                	this._parseMessage(  msg );
+                } 
+                
+                if( lex.token != '}'# ){
+                	error("缺少'}' (行:" + lex.line + ") 匹配'}'(行:" +beginLine + ")",2)
+                } 
+                 
+                lex.next(); 
+            }
+            else if ( ..string.cmp( lex.data,'enum') == 0 )  {
+                lex.next();//exit 'enum'
+            	lex.checkKeyword()
+            	var nameEnum = lex.data;
+            	 
+            	lex.next();
+            	lex.check('{'#);
+            	  
+            	var body = lex.matchNext("%{}");
+            	body = ..string.replace(body,"    ",'\t');//规范缩进格式
+            	body = ..string.replace(body,'\t\t','\t');//移除多余缩进
+            	body = ..string.replace(body,'\t\\}','}');//移除多余缩进 
+            	msgParent.subEnum[nameEnum] = body;    
+            	
+            }
+            else if ( ..string.cmp( lex.data,'package') == 0 )  {  
+            
+            	lex.next();//exit 'package'
+            	lex.checkKeyword()
+            	
+            	if(  msgParent == this ){
+            		if(#msgParent.nameSpace){
+            			this.package = lex.data;  
+            		}
+            		else {
+            			this.nameSpace = lex.data;  
+            		}
+            		
+            	}
+            	else{
+            	    if( (#this.package) && ..string.startWith(lex.data,this.package ) ){
+            	    	msgParent.nameSpace = ..string.right(lex.data,-(#this.package+2)); 
+            	    }
+            	    else {
+            	    	msgParent.nameSpace = lex.data; 
+            	    }
+            	}
+            	lex.next();
+            	lex.checkNext(';'#);
+            	
+            }
+            else if ( ..string.cmp( lex.data,'service') == 0 )  {
+                lex.matchNext("%{}");
+            }
+            else if ( ..string.cmp( lex.data,'oneof') == 0 )  {
+                lex.next();
+                lex.checkKeyword();
+                ..table.push( this.oneof ,lex.data );
+                lex.next();  
+                lex.checkNext('{'#) 
+            }
+            else if ( ..string.cmp( lex.data,'import') == 0 )  {
+                lex.next();
+                lex.checkString();
+                var path = lex.data;
+                this.importFile(path,msgParent);
+                lex.next();
+            }
+            else if ( ..string.cmp( lex.data,'syntax') == 0 )  {
+                lex.next();
+                lex.checkNext('='#);
+                lex.checkString();
+                this.syntax = lex.data;
+                if(this.syntax=="proto3"){
+                	//兼容 proto3 语法
+                }
+                
+                lex.next();
+                lex.testNext(';'#);
+            }
+            else { 
+            
+                var field = ..protobuf.parser.field();
+                field.comment = lex.comment; 
+                if(#this.oneof){
+                    field.oneof = this.oneof[#this.oneof];
+                }
+                
+                if( msgParent.fieldTypes ){
+                	..table.push(msgParent.fieldTypes,field);
+                }
+                 
+                if ( ..string.cmp( lex.data,'required') == 0 ) {
+                	//field.required = true;
+                	lex.next()
+                }
+                elseif ( ..string.cmp( lex.data,'optional') == 0 ) {
+                	//field.optional = true;
+                	lex.next()
+                } 
+                elseif ( ..string.cmp( lex.data,'singular') == 0 ) {
+                	//field.optional = true;
+                	lex.next()
+                } 
+                elseif ( ..string.cmp( lex.data,'repeated') == 0 ) {
+                	field.repeated = true;
+                	lex.next()
+                }
+                elseif ( ..string.cmp( lex.data,'option') == 0 ) {
+                	field.option = true;
+                	lex.next()
+                	
+                	field.varName = lex.data;
+                	lex.next();
+                	
+                	lex.checkNext('='#);
+                	
+                	if( !msgParent.option ){
+                		msgParent.option = {}
+                	}
+                	msgParent.option[field.varName] = lex.data; 
+                	lex.next();
+                	lex.checkNext(';'#); 
+                	continue;
+                } 
+                
+                field.typeName = lex.data; 
+                lex.next();  
+                
+                if( lex.testNext('<'#) ){
+                	field.mapKeyTypeName = lex.data; 
+                	lex.next();  
+                	lex.checkNext(','#);
+                	
+                	field.mapValueTypeName = lex.data; 
+                	lex.next(); 
+                	 
+                	lex.checkNext('>'#);
+                }
+                
+                field.varName = lex.data;
+                lex.next();
+              
+                lex.checkNext('='#);
+                lex.checkNumber();
+                
+                field.fieldIndex = lex.data; 
+                lex.next(); 
+                
+                if( lex.testNext('['#) ){
+                	lex.checkKeyword()
+                	
+                	var attr = lex.data;
+                	lex.next();
+                	
+                	lex.checkNext('='#);
+                	if(lex.testKeyword()){
+                	    if(  (lex.data == "true" 
+                	        || lex.data == "false" || lex.data == "null") ){
+                	    	field[attr] = eval(lex.data);
+                	    }
+                	    else{
+                	    	//proto3 不支持默认值，所以不需要寻找在后面定义的类型
+                			field[attr] = msgParent.findType( field.typeName, lex.data );
+                		}
+                	} 
+                	else {
+                		field[attr] = lex.data;
+                	}
+                	lex.next();
+                	
+                	lex.checkNext(']'#); 
+                }
+                elseif(field.repeated && packableTypes[field.typeName] && this.syntax=="proto3"){
+                	field.packed = true;
+                }
+                 
+                lex.checkNext(';'#);
+                if(lex.token == '}'#){
+                    if(#this.oneof){
+                    	var oneof = ..table.pop(this.oneof);
+                    	lex.next();
+                    	if(lex.token == '}'#) return;
+                    } 
+                    else {
+                    	return;
+                    }
+                } 
+            }
+        } 
+    }
+} 
+
+namespace parser{
+    
+    packableTypes = {
+    	enum=1;  
+		int32=1;
+		int64=1;
+		sint32=1;
+		sint64=1;
+		sfixed32=1;
+		sfixed64=1;
+		fixed32=1;
+		fixed64=1;
+		uint32=1;
+		uint64=1;
+		float=1;
+		double=1;
+		bool=1;
+	}
+	
+}
+
+//类作为父名字空间时,import 子库必须放在类定义之后
+import protobuf.parser.lex;
+import protobuf.parser.message;
+
+/**intellisense()
+protobuf.parser() = Protobuf 结构定义文件 *.proto 解析器,\n支持 proto2,proto3\n!protobuf_parser.
+!protobuf_parser.parseFile( = 编译 proto 文件
+!protobuf_parser.parseFile(.(protoFile,namespace,inProject) = 编译 proto 文件。\n\n@protoFile 参数指定 proto 文件路径。\n可选用 @namespace 参数指定默认根名字空间\n可选用 @inProject 参数指定是否优先在工程目录下创建用户库\n└──@inProject 默认为 true \n└──如果 @inProject 为 false 则始终在 "/" 目录下创建用户库\n└──工程内部运行的代码文件 "/" 等价于工程目录\n\n字段名中下划线后接小写字母会自动去掉下划线转换为驼峰式命名
+!protobuf_parser.parse( = 编译 proto 代码
+!protobuf_parser.parse(.(strProto,namespace,inProject) = 编译 proto 代码。\n\n@strProto 参数指定 proto 代码。\n可选用 @namespace 参数指定默认根名字空间\n可选用 @inProject 参数指定是否优先在工程目录下创建用户库\n└──@inProject 默认为 true \n└──如果 @inProject 为 false 则始终在 "/" 目录下创建用户库\n└──工程内部运行的代码文件 "/" 等价于工程目录\n\n字段名中下划线后接小写字母会自动去掉下划线转换为驼峰式命名
+end intellisense**/