欢迎访问 Forcal程序设计

FORCAL标准字符串动态库FcString

目  录

1 什么是FcString

2 常量
string::ws 用于通过函数new申请Unicode字符串对象,例如:new[string::ws,10] 。通过这种方式申请的对象不能由函数oo自动销毁,故不推荐使用。
string::Regex 用于通过函数new申请正则表达式对象,例如:new[string::Regex] 。通过这种方式申请的对象不能由函数oo自动销毁,故不推荐使用。
string::reIgnoreCase 用于函数string::ComRegex,其他类似的常量还有string::reSingleline, string::reMultiline, string::reGlobal, string::reRightToLeft, string::reExtended, string::reNoFlag。

3 字符串函数

string::ns(k) 整数函数、实数函数。申请Unicode字符串对象,长度为k。在oo函数中调用该函数,将返回临时对象,否则返回一般对象
string::ws("abc") 整数函数、实数函数。申请Unicode字符串对象,并用字符串初始化。在oo函数中调用该函数,将返回临时对象,否则返回一般对象
string::outs(p) 整数函数、实数函数。输出Unicode字符串对象,p是字符串指针。运行错误:1:非法的字符串指针。
string::sets(p,k,c) 整数函数、实数函数。设置Unicode字符串对象的元素的值,相当于p[k]=c。p是字符串指针,k是元素地址,c是一个整数。函数仍返回p。
运行错误:1:非法的字符串指针;2:元素地址非法。
string::gets(p,k) 整数函数、实数函数。获得Unicode字符串对象的元素的值,相当于p[k]。p是字符串指针,k是元素地址。
运行错误:1:参数个数非法;2:非法的字符串指针;3:元素地址非法。
string::+ 整数函数、实数函数。两个一维字符串相加,返回新的字符串对象,用于oo函数。例如:oo{[ws("ab")+ws("cd")].outs()}
运行错误:1:非法的字符串指针;2:不是一维字符串(数组)。
string::= 整数函数、实数函数。定义了两种赋值操作。
1:将一个静态字符串赋值给字符串对象(string::wcscpys),使用赋值运算符“.=”,例如:f(:a)=oo{a=ns(5),a.="ab",outs(a)}
2:将一个整数赋值给字符串的元素(string::sets(p,k,c)),例如:f(:a)=oo{a=ws("abcd"),a[2]=getw("t"),outs(a)}
运行错误:1:参数太多或者太少。其他运行错误参考函数string::wcscpys和string::sets(p,k,c)的说明。
string::setstrlen 设置字符串缓冲区大小
string::fstons 将Forcal远程静态字符串传送到近程静态字符串
string::nstofs 将Forcal近程静态字符串传送到远程静态字符串
string::strtowcs 将ANSI字符串转换为Unicode字符串
string::wcstostr 将Unicode字符串转换为ANSI字符串
string::strcpy 复制ANSI字符串
string::wcscpy 复制Unicode字符串
string::strcpys 将Forcal近程静态字符串复制到ANSI字符串
string::wcscpys 将Forcal近程静态字符串复制到Unicode字符串
string::strcat 连接ANSI字符串
string::wcscat 连接Unicode字符串
string::strcats 将Forcal近程静态字符串连接到ANSI字符串的后面
string::wcscats 将Forcal近程静态字符串连接到Unicode字符串的后面
string::strcati 将一个整数连接到ANSI字符串的后面
string::wcscati 将一个整数连接到Unicode字符串的后面
string::strcatr 将一个实数连接到ANSI字符串的后面
string::wcscatr 将一个实数连接到Unicode字符串的后面
string::strcmp 比较ANSI字符串
string::wcscmp 比较Unicode字符串
string::strlen 获得ANSI字符串长度
string::wcslen 获得Unicode字符串长度
string::substr 复制ANSI子字符串
string::subwcs 复制Unicode子字符串
string::nscpy 复制近程静态字符串
string::nscpys 将FcData一维Unicode字符串复制到近程静态字符串

4 正则表达式函数

string::Regex() 整数函数,申请Regex对象。在oo函数中调用该函数,将返回临时对象,否则返回一般对象
string::ComRegex 编译正则表达式文本
string::MatchExact 验证传入的文本是否刚好匹配正则表达式
string::Match 从文本中查找匹配符合表达式的子字符串
string::GetNamedGroupNumber 通过命名分组名,返回命名分组编号
string::Replace 文本替换操作
string::IsMatched 获取是否匹配成功
string::GetStart 获取匹配到的子字符串开始位置
string::GetEnd 获取匹配到的子字符串结束位置
string::GetGroupStart 获取分组开始位置
string::GetGroupEnd 获取分组结束位置
string::MaxGroupNumber 获取正则表达式最大捕获组编号

1 什么是FcString [返回页首]

    FcString32W.dll是一个Forcal标准字符串扩展动态库,主要包含各种字符串操作函数(包括正则表达式函数),这些函数是针对FcData字符串或Forcal静态字符串进行操作的。

    在函数功能和命名上,基本与C/C++函数一致:ANSI字符串函数以str开头,Unicode字符串函数以wcs开头,函数基本上是成对出现的。此外还扩充了一些Forcal特有的字符串函数。

    在使用FcString中的字符串函数时,通常不需要考虑字符串缓冲区的大小,缓冲区不够用时,FcString会自动增加缓冲区的大小。例如字符串相加:

str1.wcscpys("f(").wcscati(k).wcscats(")=12");    //str1是FcData字符串指针,k是一个整数,若k=2,执行完后str1中的字符串为"f(2)=12",不需要考虑str1的缓冲区大小

oo{[ws("ab")+ws("cd")+ws("ef")].outs()};          //函数ws返回字符串对象,函数outs输出一个字符串

    可以看出,在对字符串连续使用函数进行操作时,Forcal的函数参数运算符“.”非常有用,增强了代码的可读性。

    在FcString中的函数是通过二级函数命名空间“string”输出的,所有函数均具有类似“string::strcat(...)”的格式。使用!using("string");可简化FcString中的函数访问。

    FcString32W.dll需要FcData32W.dll的支持,FcData32W.dll要先于FcString32W.dll加载。

3 字符串函数 [返回页首]

[返回页首][整数函数、实数函数] string::setstrlen(pstr,len):设置字符串缓冲区大小

    pstr:FcData一维字符串指针,只能是char_s或wchar_s(string)。
    len:字符串缓冲区大小。
    返回值:pstr。
    说明:该函数重新设置字符串缓冲区大小,若扩大了缓冲区,原先的字符串数据将被保留,若缩小了缓冲区,原先的字符串数据将被截断。虽然FcString会自动增加字符串的缓冲区以满足需求,但使用该函数可预先设置足够的缓冲区,提高了运行效率。使用该函数也可根据需要缩小缓冲区,释放多余的内存。

    运行错误:1:非法的字符串指针;2:不是一维字符数组;3:内存错误。

[返回页首][整数函数、实数函数] string::fstons(ForType,ForHandle,sstr,dstr,len):将Forcal远程静态字符串传送到近程静态字符串

    ForType:表达式类型。ForType=1表示整数表达式;ForType=2表示实数表达式;ForType=3表示复数表达式;ForType取其他值都是非法的。
    ForHandle:表达式句柄。
    sstr:Forcal远程静态字符串地址。
    dstr:Forcal近程静态字符串地址。
    len:Forcal近程静态字符串缓冲区大小。
    返回值:0。

    运行错误:1:非法的表达式类型;2:表达式句柄非法或者远程静态字符串地址非法;3:近程静态字符串地址非法;4:近程静态字符串缓冲区太小。

    [例子1]

a()     = "实数表达式中的字符串";
i:b(:s) = s="\[80]", string::fstons[2,HFor("a",2),a().rtoi(),s,80], printff[s];

    [例子2]

a()   = "实数表达式中的字符串";
b(:s) = s="\[80]", string::fstons[2,HFor("a"),a(),s,80], printff[s];

[返回页首][整数函数、实数函数] string::nstofs(sstr,ForType,ForHandle,dstr,len):将Forcal近程静态字符串传送到远程静态字符串

    sstr:Forcal近程静态字符串地址。
    ForType:表达式类型。ForType=1表示整数表达式;ForType=2表示实数表达式;ForType=3表示复数表达式;ForType取其他值都是非法的。
    ForHandle:表达式句柄。
    dstr:Forcal远程静态字符串地址。
    len:Forcal远程静态字符串缓冲区大小。
    返回值:0。

    运行错误:1:近程静态字符串地址非法;2:非法的表达式类型;3:表达式句柄非法或者远程静态字符串地址非法;4:远程静态字符串缓冲区太小。

    [例子]

a()   = "\[80]";
b(:s) = s="Forcal近程静态字符串", string::nstofs[s,2,HFor("a"),a(),80], printff["{1,fs}",2,HFor("a"),a()];

[返回页首][整数函数、实数函数] string::strtowcs(pstr,pwcs):将ANSI字符串转换为Unicode字符串

    pstr:FcData一维char_s字符串指针。
    pwcs:FcData一维wchar_s(string)字符串指针。
    返回值:返回转换后Unicode字符串的长度。

    运行错误:1:非法的字符串指针;2:不是一维字符数组;3:内存错误。

    [例子]

[返回页首][整数函数、实数函数] string::wcstostr(pwcs,pstr):将Unicode字符串转换为ANSI字符串

    pwcs:FcData一维wchar_s(string)字符串指针。
    pstr:FcData一维char_s字符串指针。
    返回值:返回转换后ANSI字符串的长度。

    运行错误:1:非法的字符串指针;2:不是一维字符数组;3:内存错误。

[返回页首][整数函数、实数函数] string::strcpy(pdstr,psstr):复制ANSI字符串

    pdstr:FcData一维目的char_s字符串指针。
    psstr:FcData一维源char_s字符串指针。
    返回值:pdstr

    运行错误:1:非法的字符串指针;2:不是一维字符数组;3:内存错误。

[返回页首][整数函数、实数函数] string::wcscpy(pdwcs,pswcs):复制Unicode字符串

    pdwcs:FcData一维目的wchar_s(string)字符串指针。
    pswcs:FcData一维源wchar_s(string)字符串指针。
    返回值:pdwcs

    运行错误:1:非法的字符串指针;2:不是一维字符数组;3:内存错误。

[返回页首][整数函数、实数函数] string::strcpys(pdstr,"hello"):将Forcal近程静态字符串复制到ANSI字符串

    pdstr:FcData一维目的char_s字符串指针。
    返回值:pdstr

    运行错误:1:非法的字符串指针;2:不是一维字符数组;3:字符串地址非法;4:内存错误。

    [例子]

[返回页首][整数函数、实数函数] string::wcscpys(pdwcs,"hello"):将Forcal近程静态字符串复制到Unicode字符串

    pdwcs:FcData一维目的wchar_s(string)字符串指针。
    返回值:pdwcs

    运行错误:1:非法的字符串指针;2:不是一维字符数组;3:字符串地址非法;4:内存错误。

[返回页首][整数函数、实数函数] string::strcat(pdstr,psstr):连接ANSI字符串

    pdstr:FcData一维目的char_s字符串指针。
    psstr:FcData一维源char_s字符串指针。
    返回值:pdstr

    运行错误:1:非法的字符串指针;2:不是一维字符数组;3:内存错误。

[返回页首][整数函数、实数函数] string::wcscat(pdwcs,pswcs):连接Unicode字符串

    pdwcs:FcData一维目的wchar_s(string)字符串指针。
    pswcs:FcData一维源wchar_s(string)字符串指针。
    返回值:pdwcs

    运行错误:1:非法的字符串指针;2:不是一维字符数组;3:内存错误。

[返回页首][整数函数、实数函数] string::strcats(pdstr,"hello"):将Forcal近程静态字符串连接到ANSI字符串的后面

    pdstr:FcData一维目的char_s字符串指针。
    返回值:pdstr

    运行错误:1:非法的字符串指针;2:不是一维字符数组;3:字符串地址非法;4:内存错误。

    [例子]

!using["string"];
i:a(:str,wcs) ={
  str=new[char_s,2], wcs=new[wchar_s,2],
  str.strcpys["数字"].strcati[80].strcats["是一个整数。\r\n"],
  str.strtowcs[wcs],
  printff{"{1,s}",wcs},
  delete[str],delete[wcs]
};

[返回页首][整数函数、实数函数] string::wcscats(pdwcs,"hello"):将Forcal近程静态字符串连接到Unicode字符串的后面

    pdwcs:FcData一维wchar_s(string)字符串指针。
    返回值:pdwcs

    运行错误:1:非法的字符串指针;2:不是一维字符数组;3:字符串地址非法;4:内存错误。

[返回页首][整数函数、实数函数] string::strcati(pdstr,k):将一个整数连接到ANSI字符串的后面

    pdstr:FcData一维目的char_s字符串指针。
    k:整数。
    返回值:pdstr

    运行错误:1:非法的字符串指针;2:不是一维字符数组;3:内存错误。

    [例子]

[返回页首][整数函数、实数函数] string::wcscati(pdwcs,k):将一个整数连接到Unicode字符串的后面

    pdwcs:FcData一维wchar_s(string)字符串指针。
    k:整数。
    返回值:pdwcs

    运行错误:1:非法的字符串指针;2:不是一维字符数组;3:内存错误。

[返回页首][整数函数、实数函数] string::strcatr(pdstr,r):将一个实数连接到ANSI字符串的后面

    pdstr:FcData一维目的char_s字符串指针。
    r:实数。
    返回值:pdstr

    运行错误:1:非法的字符串指针;2:不是一维字符数组;3:内存错误。

[返回页首][整数函数、实数函数] string::wcscatr(pdwcs,r):将一个实数连接到Unicode字符串的后面

    pdwcs:FcData一维wchar_s(string)字符串指针。
    r:实数。
    返回值:pdwcs

    运行错误:1:非法的字符串指针;2:不是一维字符数组;3:内存错误。

[返回页首][整数函数、实数函数] string::strcmp(pdstr,psstr):比较ANSI字符串

    pdstr,psstr:FcData一维目的char_s字符串指针。
    返回值: 返回值为0表示两个字符串相等;返回值小于0表示按照字母顺序,第一个字符串小于第二个字符串;返回值大于0表示按照字母顺序,第一个字符串大于第二个字符串。

    运行错误:1:非法的字符串指针;2:不是一维字符数组。

[返回页首][整数函数、实数函数] string::wcscmp(pdwcs,pswcs):比较Unicode字符串

    pdwcs,pswcs:FcData一维wchar_s(string)字符串指针。
    返回值: 返回值为0表示两个字符串相等;返回值小于0表示按照字母顺序,第一个字符串小于第二个字符串;返回值大于0表示按照字母顺序,第一个字符串大于第二个字符串。

    运行错误:1:非法的字符串指针;2:不是一维字符数组。

[返回页首][整数函数、实数函数] string::strlen(pstr):获得ANSI字符串长度

    pstr:FcData一维目的char_s字符串指针。

    运行错误:1:非法的字符串指针;2:不是一维字符数组。

[返回页首][整数函数、实数函数] string::wcslen(pwcs):获得Unicode字符串长度

    pwcs:FcData一维目的wchar_s(string)字符串指针。

    运行错误:1:非法的字符串指针;2:不是一维字符数组。

[返回页首][整数函数、实数函数] string::substr(pdstr,psstr,begin,end):复制ANSI子字符串

    pdstr:FcData一维目的char_s字符串指针。
    psstr:FcData一维源char_s字符串指针。
    begin:源字符串开始位置。begin>=0。
    end:源字符串结束位置。若end大于源字符串有效长度,或者end为负数,则重新设置end为源字符串的最后一个字符。
    返回值:pdstr

    运行错误:1:非法的字符串指针;2:不是一维字符数组;3:非法的源字符串开始位置;4:内存错误。

[返回页首][整数函数、实数函数] string::subwcs(pdwcs,pswcs,begin,end):复制Unicode子字符串

    pdwcs:FcData一维目的wchar_s(string)字符串指针。
    pswcs:FcData一维源wchar_s(string)字符串指针。
    begin:源字符串开始位置。begin>=0。
    end:源字符串结束位置。若end大于源字符串有效长度,或者end为负数,则重新设置end为源字符串的最后一个字符。
    返回值:pdwcs

    运行错误:1:非法的字符串指针;2:不是一维字符数组;3:非法的源字符串开始位置;4:内存错误。

[返回页首][整数函数、实数函数] string::nscpy(pdns,len,psns): 复制近程静态字符串

    pdns: 近程静态目的字符串地址。
    len:近程静态目的字符串缓冲区长度。
    psns:近程静态源字符串地址。
    返回值:pdns

    运行错误:1:非法的近程静态字符串地址;2:近程静态目的字符串缓冲区长度非法或者没有足够的空间。

[返回页首][整数函数、实数函数] string::nscpys(pdns,len,pswcs,begin,end): 将FcData一维Unicode字符串复制到近程静态字符串

    pdns: 近程静态目的字符串地址。
    len:近程静态目的字符串缓冲区长度。
    pswcs:FcData一维源wchar_s(string)字符串指针。
    begin:源字符串开始位置。begin>=0。 可以缺省该参数,缺省值为begin=0。
    end:源字符串结束位置,可以缺省该参数。若end大于源字符串有效长度,或者end为负数, 或者缺省该参数,则重新设置end为源字符串的最后一个字符。
    返回值:pdns

    运行错误:1:参数个数不符合要求;2:非法的近程静态字符串地址;3:非法的源字符串指针;4:不是一维字符数组;5:近程静态目的字符串缓冲区长度非法或者没有足够的空间。

4 正则表达式函数 [返回页首]

    Forcal正则表达式使用 DEELX 正则表达式引擎。请参考:DEELX正则引擎文档,或者 DEELX正则引擎网站

    Forcal正则表达式函数都是整数函数,且只能处理Unicode字符串。

    要使用Forcal正则表达式,需要先用pRegex=new(string::Regex)pRegex=string::Regex()申请Forcal正则表达式对象,然后操作正则表达式,用完后,用delete(pRegex)销毁该对象(或者最后由系统销毁)。 如果在函数oo中使用string::Regex(),则申请的对象可被函数oo自动销毁,推荐使用这种方法。

[返回页首][整数函数] string::ComRegex(pRegex,pattern,flags):编译正则表达式文本

    pRegex:正则表达式对象。
    pattern:Forcal近程静态字符串地址,正则表达式。
    flags
表达式匹配模式。支持的匹配模式有:string::reIgnoreCase, string::reSingleline, string::reMultiline, string::reGlobal, string::reRightToLeft, string::reExtended 这 6 种模式以及它们的组合,或者使用缺省的string::reNoFlag模式。可以缺省该参数,缺省值为string::reNoFlag。详细说明如下:

    string::reIgnoreCase :匹配时忽略大小写。默认情况下,正则表达式是要区分大小写的。不管是否指定忽略大小写模式,字符类,比如 [A-Z] 是要区分大小写的。

    string::reSingleline :使小数点 "." 可以匹配包含换行符(\n)在内的任意字符。默认情况下,小数点只匹配换行符以外的任意字符,不匹配换行符。

    string::reMultiline :使 ^ 符号除了能够匹配字符串开始位置外,还能匹配换行符(\n)之后的位置;使 $ 符号除了能够匹配字符串结束位置外,还能匹配换行符之前的位置。默认情况下, ^ 符号只能匹配字符串开始位置, $ 符号只能匹配字符串结束位置。string::reSingleline 和 string::reMultiline 虽然听起来相互矛盾,但却是作用在不同的地方。因此它们是可以组合使用的。在指定了 string::reMultiline 之后,如果需要仅匹配字符串开始和结束位置,可以使用 \A 和 \Z。

    string::reGlobal :使 \G 可以用来匹配本次查找匹配的开始位置,对于连续的匹配来说,也就是上次匹配的结束位置。默认情况下, \G 没有作用。在进行替换操作(Replace)时,不管是否指定 string::reGlobal 模式,都可以进行所有的替换。是否指定 string::reGlobal 模式只是对 \G 起作用。如果希望进行有限次数的替换,可在替换操作时指定替换次数。

    string::reRightToLeft :从右向左的进行匹配。从被匹配字符串的结束位置向前进行查找匹配,同时,在表达式中也是右侧的表达式先进行匹配。表达式的写法仍然按原来的习惯:匹配次数修饰符(*, +, {n}, ……)仍然位于被修饰部分的右侧而不是左侧;^ 仍然匹配文本开始而不是文本结束;(?=xxx) 仍然是正向与搜索(向右预搜索),而不是向左;分组(group)编号仍然是从左向右进行编号;等等。不管整个表达式是否指定了 string::reRightToLeft 模式,"反向预搜索(反向零宽度断言)" 内的表达式始终采用 string::reRightToLeft 模式。

    string::reExtended :使 DEELX 忽略表达式中的空白字符,并且把从 # 开始到该行行末的内容视为注释。默认情况下,正则表达式中的空格,换行等字符将可以匹配相应的字符。指定了 string::reExtended 模式后,如果要在正则表达式中表示空白字符比如空格符号(space)时,应该用 \x20 表示,如果要在表达式中表示 # 符号,应该用 \# 表示。不管是否指定了 string::reExtended 模式,括号内以 ?# 号开始时,比如(?# xxx ),那么这一对括号以及包含的内容都始终作为注释而被忽略。

    返回值:pRegex

    说明:任何一个正则表达式对象,都需要先用该函数编译正则表达式文本后才能使用。

    运行错误:1:参数个数非法;2:非法的正则表达式对象;3:非法的近程静态字符串地址。

    例子:判断一个字符串是否全由数字组成

!using["string"];                                     //使用命名空间string
i: (:pRegex,str)=
{
    str=new(string,EndType,"12345"),                  //申请字符串
    pRegex=new(Regex),                                //申请Forcal正则表达式对象
    pRegex.ComRegex(
@"\d+"),                          //编译正则表达式文本
    pRegex.MatchExact(str),                          
//验证是否刚好匹配
    which{
        pRegex.IsMatched() : printff{"\r\nyes!\r\n"},
//匹配成功输出yes
        printff{"\r\nno!\r\n"}                       
//匹配失败输出no
    },
    delete(str), delete(pRegex)                      
//销毁字符串和正则表达式对象
};

    或者:

!using["string"];                                     //使用命名空间string
i: (:pRegex,str)=
oo{
    str=ws("12345"),                                  //申请字符串
    pRegex=Regex(),                                   //申请Forcal正则表达式对象
    pRegex.ComRegex(
@"\d+"),                          //编译正则表达式文本
    pRegex.MatchExact(str),                          
//验证是否刚好匹配
    which{
        pRegex.IsMatched() : printff{"\r\nyes!\r\n"},
//匹配成功输出yes
        printff{"\r\nno!\r\n"}                       
//匹配失败输出no
    }
};

[返回页首][整数函数] string::MatchExact(pRegex,str):验证传入的文本是否刚好匹配正则表达式

    pRegex:正则表达式对象。
    str:FcData一维wchar_s(string)字符串指针。
进行匹配的字符串。

    返回值:pRegex

    说明:所谓刚好匹配,就是要求正则表达式从文本开始位置刚好匹配到文本结束位置。匹配结果可通过函数string::IsMatched获取。

    运行错误:1:非法的正则表达式对象;2:非法的FcData字符串指针;3:不是一维字符串指针。

    例子

[返回页首][整数函数] string::Match(... ...):从文本中查找匹配符合表达式的子字符串

    格式1:string::Match(pRegex):使用上下文对象,从上次匹配结束位置或者初始化位置开始查找匹配。上下文对象需要先使用函数string::PrepareMatch进行初始化。
    格式2:string::Match(pRegex,str):Match 方法未指定开始位置,则根据当前匹配模式是否是 string::reRightToLeft 模式决定开始位置:如果是普通模式,则从 0 开始,向右查找;如果是 string::reRightToLeft 模式,则从字符串结束位置开始,向左查找。
    格式3:string::Match(pRegex,str,start):Match 方法指定了开始位置,则从指定位置开始查找。

    pRegex:正则表达式对象。
    str:FcData一维wchar_s(string)字符串指针。
进行匹配的字符串。
    start
开始查找匹配的位置

    返回值:pRegex

    说明:匹配结果可通过函数string::IsMatched等函数获取。

    运行错误:1:参数个数非法;2:非法的正则表达式对象;3:非法的FcData字符串指针;4:不是一维字符串指针。

    例子1:Match格式1:在一段 C++ 源代码文本中,查找注释

!using["string"];                                     //使用命名空间string
i: (:pRegex,str,result)=
{
    str=new(string,EndType,"int a; /* a */"),         //申请字符串,存放源代码
    result=new(string,10),                           
//申请字符串,存放匹配结果
    pRegex=new(Regex),                                //申请Forcal正则表达式对象
    pRegex.ComRegex(
@"/\*((?!\*/).)*(\*/)?|//([^\x0A-\x0D\\]|\\.)*"),  //编译正则表达式文本
    pRegex.PrepareMatch(str),                        
//匹配准备
    pRegex.Match(),                                  
//匹配子字符串
    which{
        pRegex.IsMatched() :                         
//匹配成功输出匹配结果
        {
            result.subwcs[str,pRegex.GetStart(),pRegex.GetEnd()-1],
            printff{"\r\nfound:{1,s}\r\n",result}
        },
        printff{"\r\nnot found!\r\n"}                
//匹配失败输出 not found!
    },
    delete(str), delete(result), delete(pRegex)      
//销毁字符串和正则表达式对象
};

    例子2:Match格式2:在一段 C++ 源代码文本中,查找注释

!using["string"];                                     //使用命名空间string
i: (:pRegex,str,result)=
{
    str=new(string,EndType,"int a; /* a */"),         //申请字符串,存放源代码
    result=new(string,10),                           
//申请字符串,存放匹配结果
    pRegex=new(Regex),                                //申请Forcal正则表达式对象
    pRegex.ComRegex(
@"/\*((?!\*/).)*(\*/)?|//([^\x0A-\x0D\\]|\\.)*"),  //编译正则表达式文本
    pRegex.Match(str),                               
//匹配子字符串
    which{
        pRegex.IsMatched() :                         
//匹配成功输出匹配结果
        {
            result.subwcs[str,pRegex.GetStart(),pRegex.GetEnd()-1],
            printff{"\r\nfound:{1,s}\r\n",result}
        },
        printff{"\r\nnot found!\r\n"}                
//匹配失败输出 not found!
    },
    delete(str), delete(result), delete(pRegex)      
//销毁字符串和正则表达式对象
};

    例子3:列举一段文本中所有的带小数的数字

!using["string"];                                     //使用命名空间string
i: (:pRegex,str,result)=
{
    str=new(string,EndType,"12.5, a1.1, 0.123, 178"), //申请字符串,存放文本
    result=new(string,10),                           
//申请字符串,存放匹配结果
    pRegex=new(Regex),                                //申请Forcal正则表达式对象
    pRegex.ComRegex(
@"\b\d+\.\d+"),                   //编译正则表达式文本
    pRegex.PrepareMatch(str),                        
//匹配准备
    pRegex.Match(),                                  
//匹配子字符串
    (pRegex.IsMatched()).while{                      
//匹配成功输出匹配结果
        result.subwcs[str,pRegex.GetStart(),pRegex.GetEnd()-1],
        printff{"\r\n{1,s}",result},
        pRegex.Match()                               
//匹配子字符串
    },
    delete(str), delete(result), delete(pRegex)      
//销毁字符串和正则表达式对象
};

    或者:

!using["string"];                                     //使用命名空间string
i: (:pRegex,str,result)=
oo{
    str=ws("12.5, a1.1, 0.123, 178"),                 //申请字符串,存放文本
    result=ns(10),                                   
//申请字符串,存放匹配结果
    pRegex=Regex()                                    //申请Forcal正则表达式对象
},
pRegex.ComRegex(
@"\b\d+\.\d+"),                       //编译正则表达式文本
pRegex.PrepareMatch(str),                            
//匹配准备
pRegex.Match(),                                      
//匹配子字符串
(pRegex.IsMatched()).while{                          
//匹配成功输出匹配结果
    result.subwcs[str,pRegex.GetStart(),pRegex.GetEnd()-1],
    printff{"\r\n{1,s}",result},
    pRegex.Match()                                   
//匹配子字符串
};

[返回页首][整数函数] string::GetNamedGroupNumber(pRegex,GroupName):通过命名分组名,返回命名分组编号

    pRegex:正则表达式对象。
    GroupName:Forcal近程静态字符串地址,命名分组名。

    返回值:pRegex

    运行错误:1:非法的正则表达式对象;2:非法的近程静态字符串地址。

[返回页首][整数函数] string::PrepareMatch(pRegex,tstring,start):初始化上下文对象,准备从文本中查找匹配符合表达式的子字符串

    pRegex:正则表达式对象。
    tstring:FcData一维wchar_s(string)字符串指针。
进行匹配的字符串。
    start: 开始查找的起始位置。可以缺省该参数,此时根据当前匹配模式是否是 string::reRightToLeft 模式决定开始位置:如果是普通模式,则从 0 开始,向右查找;如果是 string::reRightToLeft 模式,则从结束位置开始,向左查找。

    返回值:pRegex

    运行错误:1:参数个数非法;2:非法的正则表达式对象;3:非法的FcData字符串指针;4:不是一维字符串指针。

    例子

[返回页首][整数函数] string::Replace(pRegex,str,rplto,newstr,start,ntimes):文本替换操作

    pRegex:正则表达式对象。
    str:FcData一维wchar_s(string)字符串指针。
被进行替换的初始文本。
    rplto:Forcal近程静态字符串地址。“替换为”字符串,将匹配到的子字符串替换成 rplto 字符串

    newstr:FcData一维wchar_s(string)字符串指针。 存放替换后得到的新字符串

    start
进行查找替换的开始位置。可以缺省该参数(默认-1),此时根据是否是 string::reRightToLeft 自动决定开始位置。
   
ntimes指定进行替换的次数。可以缺省该参数(默认-1),此时表示替换所有匹配。

    返回值:pRegex

    运行错误:1:参数个数非法;2:非法的正则表达式对象;3:非法的FcData字符串指针;4:不是一维字符串指针;5:非法的近程静态字符串地址;6:内存错误。

[返回页首][整数函数] string::IsMatched(pRegex):获取是否匹配成功

    pRegex:正则表达式对象。

    返回值:返回非零值表示匹配成功,返回 0 表示匹配失败。

    运行错误:1:非法的正则表达式对象。

    例子

[返回页首][整数函数] string::GetStart(pRegex):获取匹配到的子字符串开始位置

    pRegex:正则表达式对象。

    返回值: 匹配成功后,获取所匹配到的子字符串的开始位置。如果匹配失败,则返回负值。

    运行错误:1:非法的正则表达式对象。

    例子

[返回页首][整数函数] string::GetEnd(pRegex):获取匹配到的子字符串结束位置

    pRegex:正则表达式对象。

    返回值: 匹配成功后,获取所匹配到的子字符串的结束位置。如果匹配失败,则返回负值。

    运行错误:1:非法的正则表达式对象。

    例子

[返回页首][整数函数] string::GetGroupStart(pRegex,nGroupNumber):获取分组开始位置

    pRegex:正则表达式对象。
    nGroupNumber:分组编号。

    返回值: 获取指定分组捕获的字符串的开始位置。如果指定分组未捕获,或者整个表达式未匹配成功,则返回负值。

    运行错误:1:非法的正则表达式对象。

[返回页首][整数函数] string::GetGroupEnd(pRegex,nGroupNumber): 获取分组结束位置

    pRegex:正则表达式对象。
    nGroupNumber:分组编号。

    返回值: 获取指定分组捕获的字符串的结束位置。如果指定分组未捕获,或者整个表达式未匹配成功,则返回负值。

    运行错误:1:非法的正则表达式对象。

[返回页首][整数函数] string::MaxGroupNumber(pRegex):获取正则表达式最大捕获组编号

    pRegex:正则表达式对象。

    返回值:返回最大分组编号。

    运行错误:1:非法的正则表达式对象。


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