L脚本语言语法手册
0.12版
简 介
L脚本语言是一个轻量级的，旨在接近自然语言的编程语言，目前支持在中文、英文基础上的编程。并可扩展为任意语种。L脚本语言的语法结构简单，程序结构相对松散，易学易用。
目前L脚本语言仍处于开发初期，功能尚不完善。目前在Windows平台提供了一个简单的源码编辑器，建议使用notepad++进行源码编辑。
目录
L脚本语言定义了单一的语法格式
动作：对象类型，对象名称，参数列表
Action:ObjectType,ObjectName,ParamList
L脚本语言的每一行代码都遵从这一条语法规则，相对其他编程语言来说，这样的设计更加简单，更容易实现，更容易学习和记忆
由于有着简洁的语法，L脚本语言的解释引擎实现相比比其他编程语言简单了许多，对于比较简单的编程任务，已经足够了
源码编码格式
L脚本语言是在中文环境中开发的，Windows环境下L脚本的代码允许存储为ansi格式或unicode格式，Linux环境下L脚本的代码需要存储为utf8编码格式
说明:语法文档中以红色字体标识的部分说明该项语言特性未来会在新版本中删除，现在仍为可选
L脚本语言的注释是以#打头的行，注释和空行会被解释引擎自动忽略
当解释引擎发现某行代码中包含错误时会尽可能地提供错误信息并简单地将这行代码忽略掉
任何对象必须先进行定义之后才能引用，对象定义的格式为
定义：对象类型，对象名称，初始值
define:objecttype,objectname,initialvalue
例如
定义：整数，number1,0
define:int,number1,0
定义：整数，number2,1
define:int,number2,1
定义：浮点数,double,1.0
define:double,double1,1.0
定义：字符串,string1,”helloworld”
define:string,string1,”helloworld”
如果想要将对象的内容展示出来，可以这样
显示：number1
show:number1
显示：string1
show:string1
:是分隔符用来分隔动作和对象
,是分隔符用来分隔参数列表
在这里，对象的名称可以是除:,以外的任何字符串，中文、英文、韩文都是可以的
如果仅知道对象名字想要知道对象的类型，可以通过以下方式查询
获取：类型，对象名字，保存对象类型的字符串名
例如
获取:类型,int1,str1
显示:str1
获取:类型,func1,str1
显示:str1
获取:类型,123456,str1
显示:str1
L脚本语言内置了对整数和浮点数的支持，允许进行四则运算、逻辑运算以及取余数等
整数定义的格式为
定义：整数，整数的名称，整数的初始值(可选)
define:int,nameofint,initialvalue(optional)
浮点数定义的格式为
定义：浮点数，浮点数的名称，浮点数的初始值(可选)
define:double,nameofdouble,initialvalue(optional)
整数和浮点数定义时若没有初始值，则默认初始化为0
数值计算和逻辑运算必须遵从固定的格式
计算：表达式的内容，表达式的内容,…
compute:expression,expression,…
“计算”关键字是可以省略的
表达式的内容，表达式的内容,…
expression,expression,…
如
计算：number1+number2
compute:number1+number2
计算：number1*number2
compute:number1*number2
计算：number1>number2
compute:number1>number2
计算:number1=number2+100,number1=number*3
compute: number1=number2+100,number1=number*3
每一行代码的运行结果会保存到一个“结果”对象中，这个对象是全局的
所以如果我们想要把数值计算的结果显示出来，就可以这样写
计算：number1+number2*100
compute:number1+number2*100
显示：结果
show:result
表达式的个数可以是任意多个，L脚本语言会依次计算每一个表达式，并把最后一个表达式的运算结果存入“结果”对象
加减乘除四则运算
加法
计算：number+number2
compute:number+number2
显示：结果
show:result
减法
计算：number1-number2
compute:number1-number2
显示：结果
show:result
乘法
计算：number1*number2
compute:number1*number2
显示：结果
show:result
除法
计算：number1/number2
compute:numbe1/number2
显示：结果
show:result
取余数
计算：number1%number2
compute:number1%number2
显示：结果
show:result
赋值
计算：number1=number2+1
compute:number1=number2+1
显示：结果
show:result
计算：number1+=number2
compute:number1+=number2
计算：number1-=number2
compute:number1-=number2
计算：number1*=number2
compute:number1*=number2
计算：number1/=number2
compute:number1/=number2
计算：number1%=number2
compute:number1%=number2
括号的使用
乘法 除法 取余数 操作的优先级高于 加法和减法 同级的运算保持左结合性，因此如果希望改变运算的顺序，需要通过使用括号，如
计算：(number1+number2)*100
compute:(number1+number2)*100
逻辑运算
L脚本语言中逻辑值"真"等价于数值1, 逻辑值"假"等价于数值0
因此逻辑运算的值仅有1和0两种状态
比较大小
计算：number1>number2
compute:number1>number2
显示：结果
show:result
计算：number1>=number2
compute:number1>=number2
计算：number1<number2
compute:number1<number2
计算：number1<=number2
compute:number1<=number2
计算：number1==number2
compute:number1==number2
逻辑与
计算：(number1>=number2)&&( number3>=number4)
compute: (number1>=number2)&&(number3>=number4)
逻辑或
计算：(number1==number2)||( number1==number3)
compute: (number1==number2)||(number1==number3)
逻辑非
计算：!(number1==number2)
compute: !(number1==number2)
位运算
按位取反(未实现)
计算：~number1
compute: ~number1
按位左移
计算：number1 << number2
compute: number1 << number2
number1按位左移number2位
按位右移
计算：number1 >> number2
compute: number1 >> number2
number1按位右移number2位
按位与
计算：number1 & number2
compute: number1 & number2
按位或
计算：number1 | number2
compute: number1 | number2
按位异或
计算：number1 ^ number2
compute: number1 ^ number2
L脚本语言中支持条件分支，叫做“如果”语句，格式为
如果：条件表达式或逻辑运算表达式，条件为真时执行的语句
否则：条件为假时执行的语句
test:expression,action:
otherwise:action:
例如
如果：number1>number2,显示："大于"
test:number1>number2,show:”bigthan!”
否则：显示：“小于”
otherwise:show:”lessthan!”
在L脚本语言中循环语句叫做“当”语句，格式为
当：条件表达式或逻辑运算表达式，条件为真时重复执行的语句
while:expression,action:
或者
当:条件表达式或逻辑运算表达式
#循环语句块
#如果:条件满足,跳出
#如果:条件满足,继续
结束
可以在循环体中通过 跳出 命令来结束循环，类似于C语言的break
可以在循环体中通过 继续 命令来忽略后面的循环体，重新考察条件表达式开始新一轮的循环，类似于C语言的continue
例如
当：1，调用：函数，function1
while:1,call:function,function1
定义:整数,int1,100
当:int1>0
如果:int1==50,跳出
显示:int1
计算:int1-=1
结束
字符串定义时可以进行初始化，若没有初始化参数，则默认为空串
字符串定义的格式为
定义：字符串，字符串的名称，字符串的初始值
define:string,nameofstring,intialvaue
例如
定义：字符串,string1,”hello”
define:string,string1,”hello”
定义：字符串，string2," world"
define:string,string2,” world”
支持字符串的连接操作
格式为
连接：字符串，第一个字符串，第二个字符串
connect:string,first string,second string
连接：字符串,string1,string2
connect:string,string1,string2
显示：string1
show:string1
支持字符串取子串的操作
格式为
取子串：子串名称，原字符串名称，取子串时的其实位置，取子串的长度
getsubstring:nameofsubstring,originalstring,startpos,lengthofsubstring
如
定义：字符串,string3
define:string,string3
取子串:string3,string1,1,3
getsubstring:string3,string1,1,3
允许将字符串的内容清空
格式为
清空：字符串，字符串的名称
clear:string,nameofstring
支持字符串查找子串的操作
格式为
查找：字符串,原字符串,子串
find:string,originalstring,substring
如果找到子串，“结果”对象置为一个整数对象，其值是1否则值是0
如
查找：字符串,string1,string2
find:string,string1,string2
支持字符串替换子串的操作
格式为
替换:字符串,原字符串,字符串中的子串,替换的子串
replace:string,originalstring,substring,replacedstring
和查找一样，如果找到子串，“结果”对象置为一个整数对象，其值是1否则值是0
如
替换:字符串,string1,string2,"xyz"
replace:string,string1,string2,”xyz”
字符串可以转换大小写，还可以反转
语法格式为
转换：字符串名称，大写
transform:nameofstring,upper
转换：字符串名称，小写
transform:nameofstring,lower
转换：字符串名称，反转
transform:nameofstring,reverse
字符串可以转换为整数或浮点数
语法格式为
转换：整数名，字符串名
转换：浮点数名，字符串名
transform:nameofdouble,nameofstring
任何对象都可以转换为字符串
语法格式为
转换：字符串名，对象名
transform:nameofstring,nameofobject
正则表达式本身是特殊格式的字符串，定义格式为
定义:正则表达式,正则表达式的名称,正则表达式的内容
define:regexp,name ofregexp,regexp string content
如
定义:正则表达式,regexp1,"\d\d\d"
define:regexp,regexp1,”\d\d\d”
如果要使用正则表达式匹配某个字符串，格式如下
定义：字符串,str2,"abc"
define:string,str2,”abc”
定义：字符串,str1,123
define:string,str1,123
匹配：正则表达式,regexp1,str1
match:regexp,regexp1,str1
匹配：正则表达式,regexp1,str2
match:regexp,regexp2,str2
和其它编程语言一样，函数必须先定义之后才能进行调用
函数定义的格式为
定义：函数，函数的名称，形式参数列表
开始：函数，函数的名称
#函数体
结束：函数，函数的名称
结束
define:function,name_of_function,formalparameters
start:function, name_of_function
#functionbody
end:function, name_of_function
end
函数的参数可以是0个或任意多个，函数的参数必须是对象或静态数值
函数体可以是任意合法的代码行，但是不允许函数的嵌套定义
函数体必须是由对称的“开始“，“结束”包起来
函数体内部允许定义局部对象，其生存期随函数调用时产生，函数调用结束时销毁
函数调用的格式为
调用：函数，函数的名称，实际参数列表
调用：函数的名称，实际参数列表
函数的名称:实际参数列表
call:function,name_of_function,realparameters
call:name_of_function,realparameters
name_of_function:realparameters
L脚本语言的函数没有返回值，因此，如果我们需要保存函数运行的结果，可以将所需结果对象作为参数传递给函数
L脚本语言的函数参数是占位符号，并不能表示参数的对象类型，因此，在设计函数的时候需要自己确保形式参数与实际参数的类型一致，这样设计是为了实现简单，同时考虑L脚本语言并不适合处理大型任务，因此函数实现不会过于复杂，但是使用时应小心可能存在的问题
函数调用的例子代码
定义:整数,ab,22
定义:函数,乘以二,参数1
开始:函数,乘以二
计算:参数1=参数1*2
结束:函数,乘以二
乘以二:ab
显示:ab
L脚本语言中的数组是对象数组，数组的大小在定义时确定，数组的元素可以是静态数值，静态字符串，或同一类型的对象
数组可以在定义时初始化，初始化时确定数组的类型和大小
也可以定义一个有大小无类型的空值数组，对这个数组的元素进行第一次赋值时确定数组元素的类型
数组定义的语法格式为
定义:数组,数组对象的名称,元素列表
定义:数组,数组对象的名称,[数组的大小]
可以通过下标或元素名的方式访问数组的元素
数组对象的名称[下标]
数组对象的名称[元素的名称]
例如
定义:数组,array1,1,2,3,4,5,6,7
显示:array1
定义:数组,array2,abc,def,fgh,ghi,ddd,"123"
显示:array2
定义:字符串,string1,aaa
定义:字符串,string2,bbb
定义:数组,array3,string1,string2
显示:array3
定义:数组,array4[10]
定义:整数,int1,10
定义:整数,int2,20
定义:数组,array5,int1,int2
显示:array5[1]
计算:array5[1]=15+int2
显示:array5[1]
L脚本语言中的表的概念与Lua语言中的表的概念类似，实际上就是名字与对象之间的映射关系
表中的元素可以是任意合法的L脚本对象，表的大小是动态的，允许动态添加删除元素
表定义的语法格式为
定义：表,表的名称
define:table,name oftable object
插入：表,表的名称,对象名
insert:table,name oftable object,user object name
取大小，表，整数变量名
getsize:table,name ofint object
取元素：表，元素的别名，元素在表中的索引
getelement:table,element’sreplace name,index of element
例如
定义：字符串,str1,"hello"
define:string,str1,”hello”
定义：字符串,str2,"world"
define:string,str2,”world”
定义：整数,number1,123456
define:int,number1,123456
定义：浮点数,number2,1.75
define:double,number2,1.75
定义：表,table1
define:table,table1
插入：表,table1,str1
insert:table,table1,str1
插入：表,table1,str2
insert:table,table1,str2
插入：表,table1,number1
insert:table,table1,number1
插入：表,table1,number2
insert:table,table1,number2
定义：函数，function1,参数1，参数2
define:function,function1,param1,param2
开始:函数,function1
start:function,function1
显示：参数1
show:param1
显示：参数2
show:param2
结束:函数,function1
end:function,function1
插入：表,table1,function1
insert:table,table1,function1
显示:table1
show:table1
和数组对象类似，也可以通过下标或元素名称的方式访问表的元素
数组对象名[元素下标]
数组对象名[元素名称]
例如
定义:字符串,str1,"hello"
定义:字符串,str2,"world"
定义:整数,number1,123456
定义:浮点数,number2,1.75
定义:表,table1
插入:table1,str1
插入:table1,str2
插入:table1,number1
插入:table1,number2
显示:table1[str1]
计算:table1[number1]+=1
显示:table1[number1]
L脚本语言支持用户自定义类，以支持面向对象的类型封装
语法格式为
定义：类，类的名字
define:class,name of class
开始：类，类的名字
start:class,name of class
定义：整数，成员变量，初始值
define:int,nameof member,initialvalue
定义：字符串，成员变量字符串，初始值
define:string,nameof member,initial value
定义：函数，成员函数，成员函数参数
define:function,name of member function,formal parameters
开始：函数，成员函数
start:function, name of member function
结束：函数，成员函数
end:function, name of member function
结束
结束：类，类的名字
结束
类成员的引用
允许调用类的成员函数，语法格式为
调用：类的名字：成员函数，成员函数参数
call:classname:functionname,parameters
“调用”关键字可以省略
类的名字：成员函数，成员函数参数
classname:functionname,parameters
L脚本语言支持自定义库以及库的导入机制，以最大程度的提供灵活性，并允许将自定义的函数注册为全局动作
库文件是只包含对象定义和函数定义的脚本文件
库文件必须以#scplib 为起始行
在库中定义的对象为全局用户对象和函数为全局用户函数
使用库时需要首先导入，语法格式为
导入：库，库文件的完整路径名
import:lib,full pathof libfile
普通用户函数调用时的格式为
调用：函数，函数的名称，函数的参数列表
call:function,functionname,realparameters list
注册为全局动作的函数就可以直接通过函数名来调用，语法格式为
注册：函数，函数的名称
register:function,functionname
函数：函数的参数列表
function:real parameters list
请参考例子代码
L脚本语言中，文件和目录都是内置对象
打开文件或目录的语句会返回一个文件对象，不需要定义
格式为
打开:文件，文件对象名,文件的完整路径名
open:file,name_of_file_object,full_path_of_file
打开:目录，目录对象名,目录的完整路径
open:directory,name of directory object,full path of diretory
如：
打开:文件,file1,c:\1.txt
open:file,file1,c:\1.txt
打开:目录,dir1,c:\
open:directiory,dir1,c:\
对文件对象支持的操作有 复制、移动、删除、取大小、读取、写入
文件操作的语法格式为
复制:文件,源文件名,目标文件名
copy:file,sourcefilename,destfilename
移动:文件,源文件名,目标文件名
move:file,sourcefile,destfile
删除:文件,文件路径名
delete:file,filepathname
取大小:文件,文件对象,保存文件大小的整数对象
getsize:file,name of file object,name of int object
写入:文件,文件对象,内存对象
write:file,name of file object,name of memory object
写入:文件,文件对象,字符串对象
write:file,name of file object,name of string object
获取:属性,文件对象,保存文件属性的表对象
get:attribute,name of file object,name of table object
插入:表, 保存文件属性的表对象,属性名称
insert:table,name of table object,attribute name
设置:属性,文件对象,文件的属性
set:attribute,name of file object,name of table object
获取:文件对象,创建时间,保存创建时间的time对象名(新建)
get:fileobject,createtime,name of timeobject(create new one)
获取:文件对象,修改时间,保存修改时间的time对象名(新建)
get:fileobject,modifytime,name of timeobject
获取:文件对象,访问时间,保存访问时间的time对象名(新建)
get:fileobject,accesstime,name of timeobject
获取: 文件对象,驱动器,保存驱动器的字符串
get:fileobject,drive,name of string object
获取: 文件对象,目录,保存目录的字符串
get:fileobject,path,name of string object
获取: 文件对象,文件名,保存文件名的字符串
get:fileobject,filename,name of string object
获取: 文件对象,扩展名,保存扩展名的字符串
get:fileobject,extension,name of string object
对目录对象支持的操作有 枚举目录中的文件 、枚举目录中的子目录 、复制、 移动、 删除
打开:目录,目录对象,目录的路径
open:directory,name ofdirectory object,full path of directory
枚举:文件,目录对象,保存文件列表的表对象
enum:file,name of directory object,name of table object
枚举:子目录,目录对象,保存目录列表的表对象
enum:subdir,name of directory object,name of table object
显示:保存文件列表的表对象
show:tableobject
显示:保存目录列表的表对象
show:tableobject
复制:目录,源目录的路径,目标目录的路径
copy:directory,source directory,dest directory
移动:目录,源目录的路径,目标目录的路径
move:directory, source directory,dest directory
删除:目录,目录的路径
delete:directory,full path of directory
L脚本语言内置了对访问Windows注册表的支持
打开一个注册表项会返回一个注册表对象，在这个对象上支持读取、写入、删除操作
语法格式为
打开：注册表,注册表对象名,注册表路径,值的名称
open:registry,nameof registry object,path of registery,key name
读取：注册表,注册表对象名,字符串对象名
read:registry, nameof registry object,name of string object
写入：注册表，注册表对象名,字符串对象名
write:registry, nameof registry object,,name of string object
删除：注册表,注册表对象名
delete:registry, nameof registry object
如
打开：注册表,reg1,HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run,HttpServer
open:registry,reg1, HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run,HttpServer
读取：注册表,reg1,string1
read:registry,reg1,string1
写入：注册表，reg1,string1
write:registry,reg1,string1
删除：注册表,reg1
delete:registry,reg1
L脚本语言中，时间对象的定义方式为
定义：时间，时间对象的名称
define:time,name of time object
可以将当前时间读取到时间对象中
读取：当前时间, 时间对象的名称
read:currenttime,name oftime object
时间对象可以通过比较运算符进行比较
如果想要让脚本在运行过程中等待一段时间，可以调用睡眠语句
睡眠：需要睡眠的毫秒数
sleep:millisecond
可以将时间对象的小时,分,秒读入到整数变量中
语法格式为
获取:时间对象名,时,整数变量名
get:timeobj1,hour,inthour1
获取:时间对象名,分,整数变量名
get:timeobj1,minute,intminute1
获取:时间对象名,秒,整数变量名
get:timeobj1,second,intsecond1
例如：
定义：时间,time1
define:time,time1
读取：当前时间,time1
read:currenttime,time1
显示：time1
show:time1
睡眠：1000
sleep:1000
定义：时间,time2
define:time,time2
读取：当前时间，time2
read:currenttime,time2
显示：time2
show:time2
如果:((time1<time2)||(time1==time2)),显示："time1早于或等于time2"
test: ((time1<time2)||(time1==time2)),show:”time1early than or equal to time2”
目前L脚本支持TCP和UDP协议的网络访问，后台使用阻塞式socket实现
对网络的访问通过网络连接对象和地址对象完成
定义地址对象的格式为
定义：地址,地址对象的名称,IP(如127.0.0.1),端口号(如27015)
define:address,name of address object,IP,port
定义网络连接对象的格式为
定义：网络连接,网络连接的名称,TCP或UDP
define:netconnection,name of netconnection object,protocol type
针对网络连接对象的动作有监听，连接，发送，接收 格式为
连接: 网络连接的名称, 地址对象的名称
connect:netconnection object,addressobject
发送: 网络连接的名称,字符串对象名
send:netconnectionobject ,stringobject
接收: 网络连接的名称, 字符串对象名
receive:netconnection object,stringobject
详细请参考例子代码
L脚本语言内置了对HTTP协议的支持，可以实现http客户端功能
语法结构如下
定义：HTTP连接,网站连接
define:httpconnection,httpconnection object name
获取:网站连接,URL地址,保存页面内容的字符串
get:httpconnectionobject,url address,string object
提交：网站连接，URL地址，保存提交内容的字符串，保存响应信息的字符串
post:httpconnectionobject,url address,submit content string,reponsestring
例如
定义：HTTP连接,网站连接
define:httpconnection,webconn
定义：字符串，页面Url
define:string,url
定义：函数，页面抓取
define:function,getweb
开始：函数，页面抓取
start:function,getweb
显示：请输入网站URL地址
show:”pleaser input url address”
等待：用户输入，页面Url
warit:userinput,url
获取:网站连接,http://www.126.com,页面Url
get: webconn, http://www.126.com,url
显示:页面Url
show:url
打开:文件,file1,c:\1.html
open:file,file1,c:\1.html
写入:文件,file1,页面Url
write:file,file1,url
结束：函数，页面抓取
end:function,getweb
当：1，调用：函数,页面抓取
while:1,call:function,getweb
定义：HTTP连接,网站连接
define:httpconnection,webconn
定义：字符串，页面Url,http://www.baidu.com
define:string,url,http://www.baidu.com
定义：字符串，表单数据,wd=123
define:string,forms,wd=123
定义：字符串，响应信息
define:string,response
提交:网站连接,页面Url,表单数据,响应信息
submit:webconn,url,forms,response
显示：响应信息
show:response
在程序中我们经常会用到随机信息
在L脚本语言中，随机数是一类对象，实际上是特殊的整数类型
使用方法为
生成：随机数,随机数对象的名称
generate:randomnumber, name of random number
刷新：随机数, 随机数对象的名称
refresh:randomnumber,name of random number
例如
生成：随机数,random1
generate:randomnumber,random1
显示：random1
show:random1
定义：整数,count,1000
define:int,count,1000
定义：函数,genrandom
define:function,genrandom
开始：函数,genrandom
start:function,genrandom
刷新：随机数,random1
refresh:randomnumber,random1
显示：random1
show:random1
计算：count=count-1
compute:count=count-1
结束：函数,genrandom
end:function,genrandom
当：count>0,调用：函数,genrandom
while:count>0,call:function,genrandom
如果我们想要在程序中启动外部程序，可以
运行:程序,进程的名称,进程可执行文件的路径名,启动参数
run:process,process object name,full path of process file,parameter
如果想要关闭已启动的外部程序，可以
关闭:程序, 进程的名称
shutdown:process,process object name
例如:
运行:程序,proc1,notepad.exe,c:\hello.txt
run:process,proc1,notepad.exe,c:\hello.txt
关闭:程序,proc1
shutdown:process,proc1
L脚本内置了进程通信的支持，目前支持命名管道方式的双向通信
语法格式为
打开：管道，管道对象名称,Windows管道名
写入：管道，管道对象名称,字符串名称
读取：管道，管道对象名称,字符串名称
关闭：管道，管道对象名称
例如
打开：管道，pipe1,\\.\pipe\mypipe1
open:pipe,pipe1, \\.\pipe\mypipe1
写入：管道，pipe1,string1
write:pipe,pipe1,string1
读取：管道，pipe1,string2
read:pipe,pipe1,string2
显示：string2
show:string2
关闭：管道，pipe1
close:pipe,pipe1
L脚本支持多线程，允许在脚本中派生新的线程，以支持并发操作
语法格式为
定义：线程，线程的名称，线程函数
define:thread,nameof thread object ,thread function
运行：线程,线程的名称，线程函数的参数
run:thread,name ofthread object,parameters
在这里，线程函数就是线程执行体所执行的操作，这里和调用函数很相似，但是这个函数是在另一个线程中执行的
详细的使用方法可以参考例子代码
二十一、 与C/C++的交互
由于操作系统提供的API都是C语言的接口，为了实现功能扩展，L脚本语言也允许直接调用操作系统的C语言API函数
目前，仅支持函数调用约定为__stdcall 的C语言函数
C语言的变量和L脚本语言的对象不是一一对应的关系，因此调用C语言函数的时候不能直接将L脚本语言的对象作为参数传入，但是可以进行适当的转换
L脚本语言中目前实现了6种基本的C语言数据类型对象
C整数，C无符号整数，句柄,C字符指针，C宽字符指针，指针
对应的C语言数据类型为int ,unsigned int ,HANDLE, char*,wchar_t * ,void *
这里的句柄是指WINDOWS操作系统中的句柄类型HANDLE，指针是指C语言的无类型指针void *
在调用C语言函数之前需要进行适当的定义，格式为
定义:C函数,函数别名, 动态库文件,C语言函数原名,返回值类型,参数类型列表
例如
定义:C函数,MyOutputDebugStringW, c:\windows\system32\Kernel32.dll,OutputDebugStringW,无,C宽字符指针
定义:C函数,myMessageBoxW, c:\windows\system32\user32.dll,MessageBoxW,C整数,句柄,C宽字符指针,C宽字符指针,C无符号整数
调用C语言函数时需要传入适当的参数和返回值 格式为
调用:C函数, 函数别名,返回值,参数列表
例如
调用:C函数,myMessageBoxW,返回值,参数1,参数2,参数3,参数4
L脚本编写的命令行程序可以接收用户输入的字符串，语法格式为
等待:用户输入,保存输入内容的字符串
例如
定义:字符串,字符串1
等待:用户输入,字符串1
显示:字符串1
二十三、 调试器使用
L脚本语言提供了一个简单的调试器，用来进行脚本源代码的调试，在调试器中打开文件后，选中行点击右键即可对代码行设置断点，点击调试按钮即开始调试过程，当脚本执行到设置了断点的行后就会中断下来，并在消息输出窗口中显示提示信息。再次右键点击已设置断点的行即可清除断点。
调试器也支持简单的调试命令
bp 行号 ，用来设置断点
bc 行号 ,用来清除断点
g ，调试运行脚本
sd ，单步调试脚本
s ，继续运行脚本
L脚本语言内置了一些密码学算法操作
如字符串加密解密(RC4) 求字符串哈希值(MD5)
内存对象加解密(AES)
语法格式为
加密：字符串名称,密钥字符串名称
encrypt:name ofstring object,name of key string
解密：字符串名称,密钥字符串名称
decrypt: name ofstring object,name of key string
求哈希：字符串名称,保存哈希值的字符串,哈希算法名称
hash: name ofstring object,hash value string name,algorithm
加密：内存对象名称, 密钥字符串名称
encrypt:name ofmemoryobject,name of key string
解密：内存对象名称, 密钥字符串名称
decrypt:name ofmemoryobject,name of key string
例如
加密：str1,str2
encrypt:str1,str2
显示：str1
show:str1
解密：str1,str2
decrypt:str1,str2
显示：str1
show:str1
求哈希：str1,str3,MD5
hash:str1,str3,MD5
定义:字符串,str1,"我是一个字符串"
定义:字符串,str2,"密钥"
申请:内存,mem1,1024
写入:mem1,str1
显示:mem1
加密:mem1,str2
显示:mem1
解密:mem1,str2
显示:mem1
释放:内存,mem1
利用L脚本语言内置的密码学算法机制，可以实现脚本内容的加密处理，以此实现算法保护
L脚本语言提供一个关键字为英文的版本，以方便英文环境的编程，语法结构与中文版相同
目前L脚本语言支持windows和Linux两个平台的开发，Linux平台上目前提供有限的支持
L脚本语言中可以直接调用python代码，这样我们可以实现L脚本和python混合编程
在L脚本中，python代码是一个对象，声明一个python对象，就可以直接调用python的代码
语法格式为
定义:PYTHON,python对象名,python版本(3.4或2.7)
调用:PYTHON, python对象名,python代码字符串
调用:PYTHON, python对象名, python代码文件的全路径
例如
定义:PYTHON,pythonscript1,3.4
调用:PYTHON,pythonscript1,"print('hello')"
调用:PYTHON,pythonscript1,H:\scriptengine\ScritpEngine\Release\pyemb7.py
L脚本语言内置了一些基本的图形对象,以支持图形化的编程
画布对象是一个窗体,在上面可以进行图形元素的绘制
目前支持在画布对象上绘制矩形、椭圆
语法格式为
定义:画布,画布对象的名称
define:canvas,nameof canvas object
显示: 画布对象的名称
show: name ofcanvas object
画:矩形, 画布对象的名称,左上角横坐标,左上角纵坐标,宽度,高度
draw:rect, name ofcanvas object,xpos ,y pos ,width,height
画:椭圆, 画布对象的名称,左上角横坐标,左上角纵坐标,宽度,高度
draw:elipse, nameof canvas object,xpos ,y pos ,width,height
为方便进行系统管理，L脚本提供了一些内置的全局对象
如 计算机 是当前运行脚本的宿主机器
我们可以通过脚本来对本机进行控制
关闭：计算机
shutdown:computer
重启：计算机
reboot:computer
挂起：计算机
suspend:computer
872
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
