欢迎访问 Lu程序设计

OpenLu V2.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由MLu64.dll提供支持,MLu64.dll由Lu64.dll提供支持。MLu64.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搜索缺省工作区文件的缺省目录是OpenLu64.exe所在目录,除非您使用了该文件的绝对路径。

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

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

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

    格式:#PATH{c:\OpenLu}

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

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

    格式:#LOAD {"dll\LuMath64","dll\LuSystem64" }

    说明:#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\LuMath64","dll\LuSystem64" }    //#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.3.8 “定位最近运行错误”选项

    如果发现可能发生的运行错误,但没有给出提示,可以使用本命令尝试定位最近的运行错误。

4.4 “命令”菜单  [目录]

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

4.5 “设置”菜单  [目录]

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

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

4.5.2 “关闭工作区”选项

    关闭工作区后,OpenLu仅加载Lu64.dll和MLu64.dll两个动态库。

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

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

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

    OpenLu仅加载Lu64.dll和MLu64.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();

    该函数将当前目录设置为OpenLu64.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()以来的运行时间。
    }#

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

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中的函数

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

7.2 MLu中的函数

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

7.3 Lu扩展动态库中的函数

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

7.4 自定义函数

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

7.5 自定义模块中的函数

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

8 添加更多帮助  [目录]

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

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

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


版权所有© Lu程序设计 2011-2021,保留所有权利
E-mail: forcal@sina.com
  QQ:630715621
最近更新: 2021年05月26日