欢迎访问 Lu程序设计

OpenLu V1.0 使用说明

目 录

1 表达式和源程序 1.1 源程序的一般格式 1.2 程序的执行 1.3 源程序的完整格式 1.4 编译指令的位置和次序 2 工作区 2.1 设置缺省工作目录 2.2 设置要加载的Lu扩展动态库 2.3 设置模块 2.4 设置命令 2.5 设置Lu关键字 2.6 工作区文件举例 3 窗口和文件系统 | 4 菜单系统 4.1 “文件”菜单 4.2 “编辑”菜单 4.3 “计算”菜单 4.4 “命令”菜单 4.5 “设置”菜单 4.6 “工具”菜单 4.7 “窗口”菜单 4.8 “帮助”菜单 4.9 加速键一览表 5 工作模式 6 OpenLu中的函数 7 其他函数 8 添加更多帮助

1 表达式和源程序 [目录]

OpenLu由MLu32.dll提供支持，而MLu32.dll由Lu32.dll提供支持。MLu32.dll可以编译固定格式的Lu源程序。

使用OpenLu需要先了解Lu表达式和MLu的源程序格式。

OpenLu中使用的表达式格式与标准的Lu表达式格式完全相同。

OpenLu中使用的源程序格式与标准的MLu源程序格式完全相同。每一个源程序被编译为一个模块。在MLu中，源程序和模块几乎是同义词。

1.1 源程序的一般格式 [目录]

在MLu源文件中，可以有多个Lu表达式，表达式之间用分号“;”隔开。两个连续的分号“;;”表示前面的表达式在执行时不会输出结果。
若表达式以mvar:开头，表示自该表达式开始，后面的表达式允许使用未定义的模块变量；若表达式以unmvar:开头，表示取消这种设置。mvar:和unmvar:仅在当前模块起作用。
在源文件中可以进行注释，注释方法与C++语言相似，即：每行两个//后的内容为注释内容；在一行内或者多行之间/*...*/之间的内容为注释内容。注释不是源程序的有效部分，但可以使程序更易读。
举例如下：

//这是一个例子！灰色部分为注释，不会被执行；
2+3; //整数表达式
2.2+3.3; //实数表达式
sin(2.2+3.3i); //复数表达式
2+3;/* 从这里开始，连续几行注释：
333+222;
. . . . . . ;
555-222;
*/ sin(2.5);
exp(2.);

1.2 程序的执行 [目录]

由于表达式有些带有参数，有些不带参数，MLu在进行处理时，对于有参数的表达式只进行编译，不进行计算。
MLu只顺序执行不带参数的表达式。如果该表达式以两个连续的分号“;;”结尾，则该表达式只执行，不输出计算结果。
但是，如果表达式以~~~开头，则无论是有参表达式还是无参表达式，都是只编译，不执行，格式如下：
~~~ 2+3; //整数无参表达式，只编译，不执行
~~~ f1()=2+3; //整数无参表达式，只编译，不执行
~~~ 2.0+3; //实数无参表达式，只编译，不执行
~~~ f2()=2+3.0; //实数无参表达式，只编译，不执行
~~~ 2+3i; //复数无参表达式，只编译，不执行
~~~ f3()=2+3i; //复数无参表达式，只编译，不执行
无参表达式f1、f2和f3可以在其他可执行的表达式中被调用。

另外，如果无参表达式以感叹号!!!开头，则编译后立即执行，且以后执行模块时不再自动执行。格式如下：
!!! 2+3; //整数无参表达式，编译成功，立即执行，以后不再自动执行
!!! f1()=2+3; //整数无参表达式，编译成功，立即执行，以后不再自动执行
!!! 2.0+3; //实数无参表达式，编译成功，立即执行，以后不再自动执行
!!! f2()=2+3.0; //实数无参表达式，编译成功，立即执行，以后不再自动执行
!!! 2+3i; //复数无参表达式，编译成功，立即执行，以后不再自动执行
!!! f3()=2+3i; //复数无参表达式，编译成功，立即执行，以后不再自动执行
无参表达式f1、f2和f3可以在其他可执行的表达式中被调用。

1.3 源程序中的模块 [目录]

编译时，将源程序中的表达式编译为一个或多个模块，MLu会对每一个模块进行加锁。编译时首先设置起始模块，也称主模块（并非Lu的0#模块，恰恰相反，MLu不会将任何一个表达式编译为0#模块，定义主模块是为了与源程序中的其他模块相区别），以后每当遇到#MODULE#，开始编译为一个新的模块，称为子模块，而每当遇到#END#，回到主模块的编译。即#MODULE#和#END#之间的表达式定义为一个子模块，子模块之间不能嵌套定义。注意#MODULE#和#END#必须位于表达式的开头。

在模块中，以:::开头的表达式被编译为公有表达式（全局表达式或全局函数），能被其他模块访问到，其余的表达式均被编译为私有表达式（私有函数），其他模块无法访问。所有模块的模块号由MLu或程序员指定，不会重复，也不会被编译为0#模块。在源程序的任何地方，可用指令#USE#调用另一个模块。

模块源文件的格式如下：

//单行注释：模块名：myModule
/*
多行注释：在同一模块源文件中的所有表达式属于同一个模块；
多行注释：以~开头的表达式可被其他模块的表达式所访问；
多行注释：不以~开头的表达式只能被该模块的表达式所访问。
*/
#MODULE# //定义一个子模块；
a(x)=10+x; //私有函数，只能被该模块的表达式所访问；
!!!b()=100+100i; //私有函数，只能被该模块的表达式所访问，该表达式是在编译时执行的；
:::c(x)=x-5; //全局函数，任意模块包括本模块均可访问；
:::f(x)=a(x)+b(); //全局函数，任意模块包括本模块均可访问；
:::g(x)=a(x)+c(x); //全局函数，任意模块包括本模块均可访问；
#USE# Module1; //使用模块Module1；
ff(5)+gg(6); //函数ff()和gg()在模块Module1中定义；
#END# //子模块定义结束，可缺省；
#MODULE# //定义一个子模块；
a(x)=10-x; //私有函数，只能被该模块的表达式所访问；
:::ff(x)=a(x); //全局函数，任意模块包括本模块均可访问；
#END# //子模块定义结束，不可缺省；
f(1); //主模块中的表达式。
ff(1); //主模块中的表达式。

在其他模块中使用该模块的格式如下：

#USE# myModule; //关键字USE必须为大写，myModule是模块名称；
f(2)+g(3); //调用myModule模块中定义的函数；

1.4 编译指令的位置和次序 [目录]

在MLu中使用的 #MODULE#、#END#、#USE#、mvar:、unmvar:、:::、!!!、~~~ 等称为编译指令，用以确定一个表达式所在模块、是否私有函数等属性。这些编译指令必须位于表达式的开头，有些指令能同时使用，有些指令不能同时使用，并且在使用时有一定的次序，按先后顺序依次为：

1）编译指令#MODULE#、#END#、#USE#、mvar:和unmvar:之间没有先后顺序，可混合使用，但这些指令必须在表达式的最前面，一般单独成行。注意mvar:和unmvar:只在本模块内有效。

2）编译指令!!!、~~~不能混合使用，只能使用其中的一个。~~~表示该表达式只编译，不执行；!!!表示该表达式编译后立即执行，但以后执行模块时不再自动执行。

3）:::表示该表达式是一个全局表达式，否则是私有表达式。

如果表达式前没有使用任何一个编译指令，则按缺省表达式的类型编译为私有表达式，若该表达式是无参表达式，则执行模块时将自动执行。

2 工作区 [目录]

OpenLu使用工作区文件对工作环境进行配置。可以将任何一个打开的文件指定为工作区，也可以将任何一个打开的文件指定为缺省工作区，这样每次OpenLu启动时都将打开该文件作为工作区。OpenLu搜索缺省工作区文件的缺省目录是OpenLu32.exe所在目录，除非您使用了该文件的绝对路径。

在OpenLu运行期间工作区文件不能被关闭，但可以进行编辑修改。对工作区文件的编辑修改并不能立即生效，只有执行了菜单“设置”中的各种重载命令才会起作用。

工作区文件是一个文本文件。所有工作区设置项的标志都是以#开头的大写英文字母串。

2.1 设置缺省工作目录：#PATH [目录]

格式：#PATH{c:\OpenLu}

说明：#PATH 后大括号{...}中的内容是一个文件目录。该目录必须写在同一行中。该目录仅在进行设置时起作用。该目录仅对指定了相对路径的文件起作用，对指定了绝对路径的文件不起作用。如果没有使用#PATH设置缺省工作目录，则缺省工作目录被设置为OpenLu32.exe所在目录。如果工作区文件中包含多次用#PATH 进行的设置，则仅第一次设置起作用。

2.2 设置要加载的Lu扩展动态库：#LOAD [目录]

格式：#LOAD {"dll\LuMath32","dll\LuSystem32" }

说明：#LOAD 后大括号{...}中的内容是要加载的Lu扩展动态库列表。扩展动态库名字要放在双引号"... ..."之间。该设置忽略在尖括号<..."..." "..." ...>内的动态库。如果工作区文件中包含多次用#LOAD进行的设置，则仅第一次设置起作用。 如果动态库需要验证，动态库名称和验证字符串之间用冒号“:”隔开，例如：“my.dll:password”。

2.3 设置模块：#MODULE [目录]

格式：#MODULE
{
"aaa*module\aaa.m" //定义模块“aaa”，模块文件为“module\aaa.m”。
"ccc*module\ccc.m" //定义模块“ccc”，模块文件为“module\ccc.m”。
}

说明：#MODULE 后大括号{...}中的内容是要加载的模块列表。模块定义要放在双引号"... ..."之间。模块定义是由星号*隔开的一个字符串，星号前为模块名字，星号后为模块文件；若没有星号，则模块名字和模块文件相同。该设置忽略在尖括号<..."..." "..." ...>内的模块。

该项设置仅仅为每个模块指定了模块文件，模块文件并没有被打开。只有在使用某个模块时，才打开与之对应的模块文件进行编译，编译结果将驻留内存以提高运行效率。使用对话框“模块管理”中的“释放”功能可以清除编译结果。

如果您自己用OpenLu打开了模块文件，则在使用该模块时，将直接从内存中读取该文件。

在源程序中使用 #USE# 命令加载模块文件时，文件地址必须有效。文件地址可以是绝对地址或相对地址。相对地址是以当前源程序模块文件所在目录为起点的地址，如果当前源程序是没有保存过的新建文件，则相对地址是基于当前目录的。如果在工作区文件中给模块文件定义了模块名字， 则可以通过模块名字加载模块文件。

模块文件的定义符合MLu对模块文件的规定，详细内容请参考MLu使用说明。

2.4 设置命令：#COMMAND [目录]

格式：#COMMAND(计算)
{
"aaa*olu\aaa.txt" //定义命令“aaa”，所执行的命令文件为“olu\aaa.txt”。
"ccc*olu\ccc.txt" //定义命令“ccc”，所执行的命令文件为“olu\ccc.txt”。
}

说明：#COMMAND 后是一对小括号(...)，小括号中的内容表示在主菜单“命令”中添加一个弹出式子菜单“计算”；然后跟一对大括号{...}，大括号中的内容是要在该子菜单中添加的命令文件列表。命令定义要放在双引号"... ..."之间。命令定义是由星号*隔开的一个字符串，星号前为命令名字，星号后为命令文件。该设置忽略在尖括号<..."..." "..." ...>内的命令文件。

该项设置仅仅为每个命令指定了命令文件，命令文件并没有被打开。只有在使用某个命令时，才打开与之对应的命令文件进行编译，编译结果将驻留内存以提高运行效率。使用对话框“模块管理”中的“释放”功能可以清除编译结果。

如果您自己用OpenLu打开了命令文件，则在执行该命令时，将直接从内存中读取该文件。

命令文件实际上就是一个MLu源程序文件。

2.5 设置Lu关键字：#KEY [目录]

格式：#KEY
{
"if"
"while"
"until"
"return"
}

说明：#KEY 后大括号{...}中的内容是Lu关键字，这些关键字将用蓝色高亮显示。

2.6 工作区文件举例 [目录]

#PATH{c:\OpenLu} //#PATH（必须为大写）：设置缺省工作目录，仅在工作区设置时使用。

#LOAD {"dll\LuMath32","dll\LuSystem32" } //#LOAD（必须为大写）：设置要加载的动态库扩展。

//设置模块：#MODULE（必须为大写）。
#MODULE
{
"aaa*module\aaa.m" //定义模块“aaa”，模块文件为“module\aaa.m”。
"ccc*module\ccc.m" //定义模块“ccc”，模块文件为“module\ccc.m”。
}

//自定义命令，定义弹出式菜单“计算”：#COMMAND（必须为大写）。
#COMMAND(计算)
{
"aaa*olu\aaa.txt" //定义命令“aaa”，所执行的命令文件为“olu\aaa.txt”。
"ccc*olu\ccc.txt" //定义命令“ccc”，所执行的命令文件为“olu\ccc.txt”。
}

//自定义命令，定义弹出式菜单“绘图”：#COMMAND（必须为大写）。
#COMMAND(绘图)
{
"ddd*olu\ddd.txt" //定义命令“ddd”，所执行的命令文件为“olu\ddd.txt”。
<"fff*olu\fff.txt" //<...>中的命令将被忽略。
"ggg*olu\ggg.txt">
"eee*olu\eee.txt" //定义命令“eee”，所执行的命令文件为“olu\eee.txt”。
}

//设置Lu关键字
#KEY
{
"if"
"while"
"until"
"return"
}

3 窗口和文件系统 [目录]

OpenLu采用水平分隔窗口，上面的窗口用于输入源代码，下面的窗口输出计算结果。可以用鼠标操作两个窗口之间的分隔条调整窗口的相对大小。

OpenLu可打开多个文件进行操作。但源程序窗口只能装入一个文件进行编辑和计算，该文件称为当前文件。所有打开的文件可通过“窗口”菜单进行切换。

工作区文件是一个特殊的文件，用于对OpenLu的工作环境进行配置，该文件在运行期间不能被关闭，除此之外，其他文件可被关闭或重新打开。

OpenLu在加载一个模块文件、命令文件或者常量文件时，将先检查该文件是否已经打开，如果该文件已被打开，则直接从内存中读取该文件。

4 菜单系统 [目录]

4.1 “文件”菜单 [目录]

4.1.1 “新建”选项

新建一个文件。

4.1.2 “打开”选项

打开一个文件。

4.1.3 “关闭”选项

关闭当前文件。

4.1.4 “全部关闭”选项

关闭所有打开的文件（工作区文件除外）。

设置代码窗口的输入缓冲区和输出窗口的输出缓冲区为较小的值，释放部分内存。

4.1.5 “保存”选项

保存当前编辑的文件。

4.1.6 “全部保存”选项

保存所有编辑过的文件。

4.1.7 “另存为”选项

给当前文件另起一个名字并保存到磁盘上，然后打开该文件进行编辑。

4.1.8 “退出”选项

保存所有编辑过的文件并退出程序。

4.2 “编辑”菜单 [目录]

4.2.1 “撤消”选项

撤消最近的一次操作。

4.2.2 “恢复”选项

恢复最近的一次操作。

4.2.3 “剪切”选项

剪切选中的文本。

4.2.4 “复制”选项

复制选中的文本。

4.2.5 “粘贴”选项

将剪贴板中的文本粘贴到当前位置。

4.2.6 “删除”选项

删除选中的文本。

4.2.7 “全部选定”选项

选中活动窗口中的所有文本。

4.2.8 “查找替换”选项

在源代码窗口中从当前位置查找替换文本字符串。

4.2.9 “设置字体”选项

设置字体。

4.3 “计算”菜单 [目录]

4.3.1 “计算”选项

编译并执行源代码窗口中的源程序。模块名称为“OpenLu”。每次执行该命令都将删除以前的编译结果。

程序执行时的目录为源文件所在目录，如果是新建文件，则程序执行时的目录为当前目录。

4.3.2 “编译”选项

编译源代码窗口中的源程序。模块名称为“OpenLu”。每次执行该命令都将删除以前的编译结果。

4.3.3 “执行”选项

执行当前（最近）编译的名称为“OpenLu”的源代码。不包括当前编译的普通模块和临时模块。

程序执行时的目录为最近编译的源文件所在目录，如果是新建文件，则程序执行时的目录为当前目录。

4.3.4 “编译为普通模块并执行”选项

将当前文件编译为普通模块。模块名即当前文件名。一个源文件对应一个普通模块。编译后编译结果将被保留。

4.3.5 “编译为临时模块并执行”选项

将当前文件编译为临时模块。模块名由OpenLu自动指定。编译后编译结果将被保留。每次执行该命令都将当前文件编译为一个临时模块。

4.3.6 “计算剪贴板中文本”选项

编译并执行剪贴板中的（源程序）文本。模块名称为“OpenLu”。每次执行该命令都将删除以前的编译结果。

程序执行时的目录为当前目录。

4.3.7 “计算选中文本”选项

编译并执行源代码窗口中被选中的（源程序）文本。模块名称为“OpenLu”。每次执行该命令都将删除以前的编译结果。

程序执行时的目录为源文件所在目录，如果是新建文件，则程序执行时的目录为当前目录。

4.4 “命令”菜单 [目录]

该菜单中均为弹出式子菜单，可以执行弹出式子菜单中的命令选项。
弹出式子菜单和命令选项均在工作区文件中定义。请参考“工作区”。

4.5 “设置”菜单 [目录]

4.5.1 “设置当前文件为工作区”选项

将当前文件设置为工作区。

4.5.2 “关闭工作区”选项

关闭工作区后，OpenLu仅加载Lu32.dll和MLu32.dll两个动态库。

4.5.3 “设置当前文件为缺省工作区”选项

OpenLu每次启动都将打开缺省工作区。

4.5.4 “设置缺省工作区为空”选项

OpenLu仅加载Lu32.dll和MLu32.dll两个动态库。

4.5.5 “重载所有项目”选项

重新初始化并重新加载工作区文件中定义的所有项目，即重新加载动态库、重新加载命令、重新加载模块文件、重新加载整数常量、重新加载实数常量、重新加载复数常量。

4.5.6 “重载动态库扩展”选项

4.5.7 “重载命令”选项

4.5.8 “重载模块文件”选项

4.6 “工具”菜单 [目录]

4.6.1 “取消文件关联”选项

取消OpenLu程序和扩展名为.olu文件之间的关联。取消关联后，将不能用OpenLu程序自动打开扩展名为.olu的文件。只有在不再需要OpenLu程序时，才需要这样做。
每次运行OpenLu程序，都将建立这种关联。

4.6.2 “取消工具栏和状态栏”选项

取消工具栏和状态栏以扩大窗口，此时该选项将变为“打开工具栏和状态栏”。再次使用该选项可以打开工具栏和状态栏。

4.6.3 “模块管理”选项

打开模块管理窗口，可以运行一个模块，释放或者删除一个模块，释放全部模块等。

在OpenLu中，一个源程序对应着一个模块。模块分为四种。

标准模块：在工作区文件中设置的模块，或者通过 #USE# 命令加载的模块。只能释放模块所占空间，不能删除模块说明部分。
命令模块：在工作区文件中设置的命令。只能释放模块所占空间，不能删除模块说明部分。
普通模块：在主窗口中编译的普通模块。可全部删除。
临时模块：在主窗口中编译的临时模块。可全部删除。

无论哪种模块，编译后编译结果将被保留，以提高运行效率。释放或者删除模块可以清除编译结果。

4.6.4 “函数查询”选项

打开函数查询窗口，可以查到所有加载的函数说明（由函数LoadHelp加载）内容，为编写程序提供了方便。

查询时，可按多关键字进行组合查询，多个关键字之间用分号“;”分隔。

可以用鼠标调整窗口大小以适应阅读要求。

4.7 “窗口”菜单 [目录]

4.7.1 “下一个窗口”选项

将下一个打开的文件装入源代码编辑窗口。连续使用该选项时，除工作区文件外，其余打开的文件将被循环装入该窗口。

4.7.2 “恢复窗口”选项

OpenLu采用水平分隔窗口，上面的窗口用于输入源代码，下面的窗口输出计算结果。
可以用鼠标操作两个窗口之间的分隔条调整窗口的相对大小。
执行该选项可以恢复窗口的初始大小。

4.7.3 “工作区文件”选项

将工作区文件装入源代码编辑窗口进行编辑。

4.7.4 其他选项

显示已打开的其他文件。选中该选项可以把该文件装入源代码编辑窗口。

4.8 “帮助”菜单 [目录]

4.8.1 “帮助”选项

打开OpenLu帮助系统。

4.8.2 “帮助和支持”选项

访问作者网站以获得技术支持。

4.8.3 “技术支持”选项

给作者发送E-Mail以获得技术支持。

4.8.4 “关于 OpenLu”选项

OpenLu版权说明。

4.9 加速键一览表 [目录]

加速键 | 命令 |  | 加速键 | 命令
Ctrl+N | 新建文件 | F1 | 帮助
Ctrl+O | 打开文件 | F2 | 模块管理
Ctrl+S | 保存文件 | F3 | 函数查询
Ctrl+Z | 撤消最后一次编辑操作 | F5 | 编译并执行源代码窗口中被选中的文本
Ctrl+X | 剪切 | F6 | 编译并执行剪贴板中的文本
Ctrl+C | 复制 | F7 | 执行当前（最近）编译的源代码
Ctrl+V | 粘贴 | F8 | 编译并执行源代码窗口中的源程序
Ctrl+D | 删除 | F9 | 下一个窗口
Ctrl+A | 选中全部文本 | F10 | 恢复窗口
Ctrl+F | 查找替换字符串 |  |

5 工作模式 [目录]

OpenLu工作模式有三种，可通过函数 SetMode(i)进行设置。若加载了默认的工作区设置，也可通过命令菜单进行切换：

（1）普通编译模式：在代码窗口写好代码后，通过菜单、工具栏或快捷键F8进行编译计算。

（2）即时编译模式：在代码窗口写代码时，即时给出代码中的错误。

（3）即时编译计算模式：在代码窗口写代码时，即时给出代码中的错误，若没有错误，将进行计算给出结果。

6 OpenLu中的函数 [目录]

OpenLu中仅定义了以下几个函数：

6.1 清除输出窗口的内容：clear[];

6.2 设置OpenLu目录函数：SetOpenLuPath();

该函数将当前目录设置为 OpenLu32.exe所在目录。

6.3 加载运行错误描述函数：LoadError("err1.err","err2.err","err3.txt",...);

该函数使用字符串参数，否则返回运行错误，错误代码为1。

该函数将多个运行错误描述文件“"err1.err","err2.err","err3.txt",...”中的内容添加到Lu键树中，以提供更详细的运行错误说明。这些运行错误描述文件为文本文件，要特别注意“#”、“{”、“}”、“:”和“;”的用法，格式如下：

#gcvt{#1:数组名必须用字符串。; #2:数字位数非法。; #3:数组太小。; #4:数组不存在。;}#
#OutStr{#1:字符串地址非法。}#
#OutCharArray{#1:数组名必须用字符串。; #2:指定的数组不存在。;}#

说明：文件中，每一个函数的运行错误以“#”开头，后面紧跟函数名，函数名到“{”结束，从“{”开始，后面为该函数运行错误描述的内容，运行错误描述内容直至“}#”结束。文件中不符合此规定的内容为注释。例如第一行定义了函数gcvt的错误描述。

运行错误描述格式如下：

#-2:...; #-1:...; #1:...; #2:错误2; #3:...; ... ...

例如，当运行错误代码为2时，将输出“#2:错误2;”中的“错误2”。每一个错误描述以“#”开头，后面紧跟错误代码和一个冒号“:”，冒号“:”后为错误说明，错误说明以分号“;”结尾。

6.4 卸载运行错误描述函数：UnloadError("err1.err","err2.err","err3.txt",...);

该函数使用字符串参数，否则返回运行错误，错误代码为1。

该函数从Lu键树中卸载函数的运行错误描述，需提供运行错误描述文件“"err1.err","err2.err","err3.txt",...”才能将相应函数的运行错误描述卸载。运行错误描述文件的格式请参考“6.3 加载运行错误描述函数：LoadError...”部分。

6.5 加载函数说明：LoadHelp("fun1.hlp","fun2.hlp","fun3.txt",...);

该函数使用字符串参数，否则返回运行错误，错误代码为1。

该函数将多个函数说明文件“"fun1.hlp","fun2.hlp","fun3.txt",...”中的内容添加到Lu键树中，以提供详细的函数查询内容。这些函数说明文件为文本文件，要特别注意“#”、“{”和“}”的用法，格式如下：

        #SetRunTime{
        [实数函数] SetRunTime()：设置运行时间

            该函数记录运行时间初值。该函数与GetRunTime()配合使用，由GetRunTime()获得运行时间。
            该函数总是返回0。
        }#
        --------------------------------------------------------------------
        #GetRunTime{
        [实数函数] GetRunTime()：获得运行时间

            该函数在SetRunTime()之后使用，由GetRunTime()可以获得自执行SetRunTime()以来的运行时间。
        }#

说明：文件中，每一个函数说明以“#”开头，后面紧跟函数名，函数名到“{”结束，从“{”开始，后面为该函数说明的内容，函数说明直至“}#”结束。文件中不符合此规定的内容为注释。例如以上定义了函数 SetRunTime 和 GetRunTime 的说明。

6.6 卸载函数说明：UnloadHelp("fun1.hlp","fun2.hlp","fun3.txt",...);

该函数使用字符串参数，否则返回运行错误，错误代码为1。

该函数从Lu键树中卸载函数说明，需提函数说明文件“"fun1.hlp","fun2.hlp","fun3.txt",...”才能将相应的函数说明卸载。函数说明文件的格式请参考“6.5 加载函数说明：LoadHelp...”部分。

6.7 设置代码窗口最大值：SetCodeWinMax(n);

该函数设置代码窗口输入缓冲区的最大值。如果n（n!=0）比当前代码窗口的字符数小，则缓冲区的最大值设置为比代码窗口的字符数稍大的值。若n=0，函数返回当前的输入缓冲区最大值。其他情况下，该函数返回实际设置的输入缓冲区最大值。

实际上，OpenLu会自动调节缓冲区的大小。但使用该函数可一次设置输入缓冲区为更大的值，或者释放缓冲区的部分空间。

当执行“文件”菜单中的“全部关闭”命令时，OpenLu会设置输入缓冲区为较小的值。

6.8 设置输出窗口最大值：SetOutWinMax(n);

该函数设置输出窗口输出缓冲区的最大值。如果n（n!=0）比当前输出窗口的字符数小，则缓冲区的最大值设置为比输出窗口的字符数稍大的值。若n=0，函数返回当前的输出缓冲区最大值。其他情况下，该函数返回实际设置的输出缓冲区最大值。

实际上，OpenLu会自动调节缓冲区的大小。但使用该函数可一次设置输出缓冲区为更大的值，或者释放缓冲区的部分空间。

当执行“文件”菜单中的“全部关闭”命令时，OpenLu会设置输出缓冲区为较小的值。

6.9 设置工作模式：SetMode(i);

OpenLu工作模式有三种，可通过函数 SetMode(i)进行设置：

i=0：普通编译模式：在代码窗口写好代码后，通过菜单、工具栏或快捷键F8进行编译计算。
i=1：即时编译模式：在代码窗口写代码时，即时给出代码中的错误。
i=2：即时编译计算模式：在代码窗口写代码时，即时给出代码中的错误，若没有错误，将进行计算给出结果。

该函数返回原先的设置。

7 其他函数 [目录]

有五种给OpenLu提供函数的方式：

7.1 Lu中的函数

Lu32.dll是OpenLu最底层的支持库，该库中提供了全部一级函数和部分重要的二级函数，这些函数可在“Lu使用说明”中查询到。

7.2 MLu中的函数

MLu中定义的二级函数在“MLu使用说明”中可以查询到。

7.3 Lu扩展动态库中的函数

在Lu扩展动态库中定义的二级函数可通过该动态库的说明文件查询到。

7.4 自定义函数

在任意源程序中可自定义函数并使用之。

7.5 自定义模块中的函数

在模块中可自定义函数供其他源程序使用。在模块中输出的函数须用“:::”标识 。

8 添加更多帮助 [目录]

OpenLu可以使用函数LoadError和UnloadError加载和卸载运行错误描述，以提供更详细的运行错误说明。

OpenLu可以使用函数LoadHelp和UnloadHelp加载和卸载函数说明，以提供实时的函数查询功能。

通常将实现以上功能的程序编写成模块，然后添加到命令菜单中以方便使用。

版权所有© Lu程序设计 2011-2012，保留所有权利
E-mail: forcal@sina.com QQ：630715621
最近更新: 2011年12月27日