整数idna_to_ascii4i（const uint32_t*in，size_t inlen，char*out，int标志）{size_t长度，outlen；uint32_t*src；/*XXX不需要复制数据*/整数rc；/**ToASCII由以下步骤组成：** 1. 如果序列中的所有代码点都在ASCII范围内（0..7F）*然后跳到步骤3。*/{大小_ i；int-inasciirange；inasciirange=1；对于（i=0；i<inlen；i++）如果（in[i]>0x7F）inasciirange=0；if（inasciirange）{src=malloc（大小（in[0]）*（入口+1））；如果（src==NULL）返回IDNA_MALLOC_ERROR；memcpy（src，in，sizeof（in[0]）*入口）；src[入口]=0；转到步骤3；}}/** 2. 执行[NAMEPREP]中指定的步骤，如果存在*一个错误。[NAMEPREP]中使用了AllowUnassigned标志。*/{字符*p；p=字符串rep_ucs4_to_utf8（in，（ssize_t）入口，NULL，NULL）；如果（p==空）返回IDNA_MALLOC_ERROR；len=斯特伦（p）；做{char*newp；len=2*len+10；/*XXX最好猜猜*/newp=重新分配（p，len）；if（newp==NULL）{自由（p）；返回IDNA_MALLOC_ERROR；}p=新p；if（标志&IDNA_ALLOW_UNASSIGNED）rc=字符串rep_nameprep（p，len）；其他的rc=字符串rep_nameprep_no_unassigned（p，len）；}同时（rc==STRINGPREP_TOO_SMALL_BUFFER）；if（rc！=字符串PREP_OK）{自由（p）；返回IDNA_STRINGPREP_ERROR；}src=字符串rep_utf8_to_ucs4（p，-1，NULL）；自由（p）；if（！src）返回IDNA_MALLOC_ERROR；}第3步：/** 3. 如果设置了UseSTD3ASIIRules标志，则执行以下检查：**（a）验证无非LDH ASCII码点；也就是说，*缺少0..2C、2E。。2F、3A。。40、5B。。60和7B。。第7页。**（b）验证前后连字符-分钟是否缺失；*也就是说，在*顺序。*/如果（标志&IDNA_USE_STD3_ASCII_RULES）{大小_ i；对于（i=0；src[i]；i++）如果（src[i]<=0x2C||src[i]==0x2E||src[i]==0x2F||（src[i]>=0x3A&&src[i]<=0x40）||（src[i]>=0x5B&&src[i]<=0x60）||（src[i]>=0x7B&&src[i]<=0x7F）{自由（src）；返回IDNA_CONTAINS_NON_LDH；}如果（src[0]==0x002D||（i>0&&src[i-1]==x002D）{自由（src）；返回IDNA_CONTAINS_MINUS；}}/** 4. 如果序列中的所有代码点都在ASCII范围内*（0..7F），然后跳到步骤8。*/{大小_ i；int-inasciirange；inasciirange=1；对于（i=0；src[i]；i++）{如果（src[i]>0x7F）inasciirange=0；/*如果要跳到步骤8，请将字符串复制到输出缓冲区*/如果（i<64）输出[i]=src[i]；}如果（i<64）输出[i]=“\0”；其他的{自由（src）；返回IDNA_INVALID_LENGTH；}if（inasciirange）转到步骤8；}/** 5. 验证序列不是以ACE前缀开头的。**/{大小_ i；int匹配；匹配=1；对于（i=0；匹配&&i<strlen（IDNA_ACE_PREFIX）；i++）如果（（（uint32_t）IDNA_ACE_PREFIX[i]&0xFF）！=src[i]）匹配=0；if（匹配）{免费（src）；返回IDNA_CONTAINS_ACE_PREFIX；}}/** 6. 使用[PUNYCODE]中的编码算法对序列进行编码*如果出现错误，则失败。*/for（len=0；src[len]；len++）;src[len]=“\0”；outlen=63-strlen（IDNA_ACE_PREFIX）；rc=punycode_encode（len，src，NULL，&outlen，&out[strlen（IDNA_ACE_PREFIX）]）；如果（rc！=PUNYCODE_SUCCESS）{自由（src）；返回IDNA_PUNYCODE_ERROR；}out[strlen（IDNA_ACE_PREFIX）+outlen]=“\0”；/** 7. 在ACE前缀之前。*/memcpy（输出，IDNA_ACE_PREFIX，strlen（IDNA_ACE _PREFIX））；/** 8. 验证代码点的数量是否在1到63之间*inclusive（不包括0）。*/第8步：自由（src）；if（strlen（out）<1）返回IDNA_INVALID_LENGTH；返回IDNA_SUCCESS；}

整数字符串rep_4i（uint32_t*ucs4，大小_t*len，大小_t最大值4len，Stringprep_profile_flags标志，const Stringprep_profile*配置文件）{尺寸t i，j；ssize_t k；size_t ucs4len=*len；整数rc；对于（i=0；配置文件[i].操作；i++）{开关（外形[i].操作）{案例STRINGPREP_NFKC：{uint32_t*q=0；if（UNAPPLICAPLEFLAGS（标志，配置文件[i].flags））断裂；if（标志&STRINGPREP_NO_NFKC&&！配置文件[i].flags）/*配置文件需要NFKC，但被叫方没有要求NFKC*/return STRINGPREP_FLAG_ERROR；q=字符串rep_ucs4_nfkc_normalize（ucs4，ucs4len）；如果（！q）return STRINGPREP_NFKC_FAILED；对于（ucs4len=0；q[ucs4len]；ucs4len++）;if（ucs4len>=最大值4len）{自由（q）；return STRINGPREP_TOO_SMALL_BUFFER；}成员（ucs4，q，ucs4len*sizeof（ucs4[0]））；自由（q）；}断裂；案例STRINGPREP_PROHIBIT_TABLE：k=字符串rep_find_string_in_table（ucs4，ucs4len，空，配置文件[i].table，配置文件[i].table_size）；如果（k！=-1）return STRINGPREP_CONTAINS_PROHIBITED；断裂；案例STRINGPREP_UNASSIGNED_TABLE：if（UNAPPLIPLEFLAGS（标志，配置文件[i].flags））断裂；if（标志&STRINGPREP_NO_UNASSIGNED）{k=字符串rep_find_string_in_table（ucs4，ucs4len，NULL，配置文件[i].table，配置文件[i].table_size）；如果（k！=-1）return STRINGPREP_CONTAINS_UNASSIGNED；}断裂；案例STRINGPREP_MAP_TABLE：if（UNAPPLICAPLEFLAGS（标志，配置文件[i].flags））断裂；rc=字符串rep_apply_table_to_string（ucs4，&ucs4len，maxucs4len，配置文件[i].表，配置文件[i].table_size）；if（rc！=字符串PREP_OK）返回rc；断裂；案例STRINGPREP_BIDI_PROHIBIT_TABLE：案例STRINGPREP_BIDI_RAL_TABLE：案例STRINGPREP_BIDI_L_TABLE：断裂；案例STRINGPREP_BIDI：{int done_prohibited=0；int done_ral=0；int done_l=0；size_t contains_ral=size_MAX；size_t contains_l=大小_最大值；对于（j=0；轮廓[j].操作；j++）if（配置文件[j].operation==STRINGPREP_BIDI_PROHIBIT_TABLE）{done_phibited=1；k=字符串rep_find_string_in_table（ucs4，ucs4len，无效的，配置文件[j].表，配置文件[j].table_size）；如果（k！=-1）return STRINGPREP_BIDI_CONTAINS_PROHIBITED；}else if（配置文件[j].operation==STRINGPREP_BIDI_RAL_TABLE）{done_ral=1；if（字符串rep_find_string_in_table（ucs4，ucs4len，NULL，配置文件[j].table，配置文件[j].table_size）！=-1)contains_ral=j；}else if（配置文件[j].operation==STRINGPREP_BIDI_L_TABLE）{done_l=1；if（字符串rep_find_string_in_table（ucs4，ucs4len，NULL，配置文件[j].table，配置文件[j].table_size）！=-1)contains_l=j；}if（！done_provented||！done_ral||！done_l）return STRINGPREP_PROFILE_ERROR；if（contains_ral！=大小_最大值&&contains_ l！=尺寸_最大值）返回STRINGPREP_BIDI_BOTH_L_AND_RAL；if（contains_ral！=大小最大）{if（！（字符串rep_find_character_in_table（ucs4[0]，配置文件[contains_ral].table，配置文件[contains_ral].table_size）！=-1&&字符串rep_ find_character_，轮廓[contains_ral].表格，轮廓[contains_ral].table_size）!= -1))返回STRINGPREP_BIDI_LEADTRAIL_NOT_RAL；}}断裂；违约：return STRINGPREP_PROFILE_ERROR；断裂；}}*len=ucs4len；return STRINGPREP_OK；}

静态gunichar*_g_utf8_normalize_wc（const gchar*str，gssize max_len，GNormalizeMode模式）{g尺寸n_wc；gunichar*wc_buffer；常量字符*p；gsize last_start；gboolean do_compat=（mode==G_NORMALIZE_NFKC|| mode==G _ NORMALIZE_NFKD）；gboolean do_compose=（mode==G_NORMALIZE_NFC|| mode==G _ NORMALIZE_NFCC）；n_wc=0；p=str；while（（max_len<0|p<str+max_len）&&*p）{const gchar*解压缩；gunichar wc=g_utf8_get_char（p）；如果（wc>=SBase&&wc<SBase+SCount）{gsize result_len；decompose_hangul（wc，NULL，&result_len）；n_wc+=结果；}其他的{decomp=查找分解（wc，do_compat）；if（解压缩）n_wc+=g_utf8_strlen（解压缩）；其他的n_wc++；}p＝g_utf8_next_char（p）；}wc_buffer=g_malloc（大小（gunichar）*（n_wc+1））；if（！wc_buffer）返回NULL；last_start=0；n_wc＝0；p=str；while（（max_len<0|p<str+max_len）&&*p）{gunichar wc=g_utf8_get_char（p）；const gchar*解压缩；int抄送；gsize old_n_wc=n_wc；如果（wc>=SBase&&wc<SBase+SCount）{gsize result_len；decompose_hangul（wc，wc_buffer+n_wc，&result_len）；n_wc+=结果；}其他的{decomp=查找分解（wc，do_compat）；if（解压缩）{常量字符*pd；for（pd=decomp；*pd！='\0'；pd=g_utf8_next_char（pd））wc_buffer[n_wc++]=g_utf8_get_char（pd）；}其他的wc_buffer[n_wc++]=wc；}如果（n_wc>0）{cc=组合类（wc_buffer[old_n_wc]）；如果（cc==0）{g_unicode匿名排序（wc_buffer+last_start，n_wc—最后开始）；last_start=old_n_wc；}}p=g_utf8_next_char（p）；}如果（n_wc>0）{g_unicode匿名排序（wc_buffer+last_start，n_wc—最后开始）；/*死赋值：last_start=n_wc*/}wc_buffer[n_wc]=0；/*所有分解和重新排序*/if（do_compose&&n_wc>0）{g尺寸i，j；int last_cc=0；last_start=0；对于（i=0；i<n_wc；i++）{int cc=COMBINING_CLASS（wc_buffer[i]）；如果（i>0&&（last_cc==0||last_cc！=cc）&&组合（wc_buffer[last_start]、wc_buffer[i]，&wc缓冲区[最后启动]））{对于（j=i+1；j<nwc；j++）wc_buffer[j-1]=wc_buffer[j]；n_wc--；i——；如果（i==最后开始）last_cc=0；其他的last_cc=COMBINING_CLASS（wc_buffer[i-1]）；继续；}如果（cc==0）last_start=i；last_cc=立方厘米；}}wc_buffer[n_wc]=0；返回wc_buffer；}

整数punycode_decode（大小_输入_长度，常量字符输入[]，size_t*输出长度，punycode_uint输出[]，无符号字符case_flags[]）{punycode_uint n，out，i，max_out，bias，oldi，w，k，digital，t；尺寸t b，j，英寸；/*初始化状态：*/n=首字母n；输出=i=0；max_out=*output_length>maxint？最大值：（punycode_uint）*输出长度；偏差=initial_bias；/*处理基本代码点：让b是输入代码的数量*//*点位于最后一个分隔符之前，如果没有分隔符，则为0，然后*//*将第一个b代码点复制到输出*/对于（b=j=0；j<输入长度；++j）if（delim（输入[j]））b=j；如果（b>最大输出）返回punycode_big_output；对于（j=0；j<b；++j）{if（case_flags）case_flags[out]=已标记（输入[j]）；if（！基本（输入[j]）返回punycode_bad_input；output[out++]=输入[j]；}对于（j=b+（b>0）；j<输入长度++j）if（！基本（输入[j]）返回punycode_bad_input；/*主解码循环：从最后一个分隔符（如果有）之后开始*//*复制基本代码点；否则从头开始*/for（in=b>0？b+1:0；in<input_length；++out）{/*in是要使用的下一个ASCII码位的索引*//*out是输出数组中的代码点数量*//*将广义可变长度整数解码为delta*//*添加到i中。溢出检查更容易*//*如果我们增加i，然后减去它的起始值*//*值以获得增量*/for（oldi=i，w=1，k=基数；；k+=基数）{if（in>=输入长度）返回punycode_bad_input；数字=解码数字（输入[in++]）；if（数字>=基数）返回punycode_bad_input；if（数字>（maxint-i）/w）返回punycode_overflow；i+=数字*w；t=k<=偏差/*+tmin*/？tmin:/*+不需要tmin*/k>=偏差+tmax？tmax:k偏差；如果（数字＜t）断裂；如果（w>maxint/（基数-t））返回punycode_overflow；w*=（基数-t）；}偏差=适应（i-oldi，out+1，oldi==0）；/*我应该从out+1到0*//*每次增加n，现在我们来解决这个问题：*/如果（i/（输出+1）>最大值-n）返回punycode_overflow；n+=i/（输出+1）；如果（n>0x10FFFF||（n>=0xD800&&n<=0xDBFF））返回punycode_bad_input；i%=（输出+1）；/*在输出的位置i插入n：*//*Punycode不需要：*//*if（basic（n））返回punycode_bad_input*/if（输出>=最大输出）返回punycode_big_output；if（case_flags）{内存移动（案例标记+i+1，案例标记+i，输出-i）；/*最后一个ASCII码点的大小写决定大小写标志：*/case_flags[i]=已标记（输入[in-1]）；}memmove（输出+i+1，输出+i，（输出-i）*sizeof*output）；输出[i++]=n；}*output_length=（size_t）输出；/*无法溢出，因为out<=*output_length的旧值*/返回punycode_success；}

整数punycode_encode（大小_输入_长度，const punycode_uint输入[]，const unsigned char case_flags[]，size_t*输出长度，字符输出[]）{punycode_uint输入_len，n，delta，h，b，bias，j，m，q，k，t；size_t输出，max_out；/*Punycode规范假定输入长度是相同的类型*//*作为代码点，因此我们需要将sizet转换为*//*punycode_uint，可能会溢出*/if（输入长度>最大值）返回punycode_overflow；input_len=（punycode_uint）输入长度；/*初始化状态：*/n=初始值n；增量=0；输出=0；max_out=*输出长度；偏差=initial_bias；/*处理基本代码点：*/对于（j=0；j<input_len；++j）{if（基本（输入[j]））{if（最大输出<2）返回punycode_big_output；output[out++]=case_flags？encode_basic（input[j]，case_flags[j]）：（char）输入[j]；}else if（输入[j]>0x10FFFF||（输入[j]>=0xD800&输入[j]<=0xDBFF）返回punycode_bad_input；/*else if（input[j]<n）返回punycode_bad_input*//*（带无符号代码点的Punycode不需要）*/}h=b=（punycode_uint）输出；/*无法溢出，因为out<=input_len<=maxint*//*h是已处理的代码点数量，b是*//*基本码点数，out是ASCII码的编号*//*已输出的点*/如果（b>0）output[out++]=分隔符；/*主编码循环：*/while（h<input_len）{/*所有非基本代码点<n*//*已处理。查找下一个较大的：*/对于（m=maxint，j=0；j<input_len；++j）{/*if（基本（输入[j]））继续*//*（Punycode不需要）*/if（输入[j]>=n&&输入[j]<m）m=输入[j]；}/*增加增量足够提前解码器*//*<n，i>状态为<m，0>，但要防止溢出：*/如果（m-n>（最大值-增量）/（h+1））返回punycode_overflow；delta+=（m-n）*（h+1）；n=米；对于（j=0；j<input_len；++j）{/*Punycode不需要检查输入[j]是否基本：*/if（输入[j]<n/*|basic（输入[j]）*/）{如果（++delta==0）返回punycode_overflow；}if（输入[j]==n）{/*将增量表示为广义可变长度整数：*/对于（q=δ，k=基数；；k+=基数）{if（输出>=最大输出）返回punycode_big_output；t=k<=偏差/*+tmin*/？tmin:/*+不需要tmin*/k>=偏差+tmax？tmax:k偏差；如果（q<t）断裂；输出[out++]=编码数字（t+（q-t）%（基数-t），0）；q=（q-t）/（基数-t）；}输出[out++]=编码数字（q，case_flags&&case_frags[j]）；偏差=适应（δ，h+1，h==b）；增量=0；++h；}}++增量，++n；}*output_length=输出；返回punycode_success；}

整数idna_to_ascii_4z（常量uint32_t*输入，字符**输出，int标志）{const uint32_t*开始=输入；const uint32_t*结束；char buf[64]；char*out=空；整数rc；/*1）当点用作标签分隔符时，以下内容字符必须识别为点：U+002E（句号），U+3002（表意全停），U+FF0E（全停），U+FF61（半角表意句号）*/if（输入[0]==0）{/*处理隐式零长度根标签*/*输出=malloc（1）；if（！*输出）返回IDNA_MALLOC_ERROR；strcpy（*输出，“”）；返回IDNA_SUCCESS；}if（DOTP（输入[0]）&&输入[1]==0）{/*处理显式零长度根标签*/*输出=malloc（2）；if（！*输出）返回IDNA_MALLOC_ERROR；strcpy（*输出，“.”）；返回IDNA_SUCCESS；}*输出=NULL；做{end=开始；for（；*end&&！DOTP（*end）；结束++）;if（*end=='\0'&&start==end）{/*处理显式零长度根标签*/buf[0]=“\0”；}其他的{rc=idna_to_ascii4i（开始，（size_t）（结束-开始），buf，标志）；如果（rc！=IDNA_SUCCESS）{自由（退出）；返回rc；}}if（输出）{size_t l=字符串（输出）+1+字符串（buf）+1；char*newp=重新分配（out，l）；if（！newp）{自由（退出）；返回IDNA_MALLOC_ERROR；}out=newp；strcat（输出，“.”）；strcat（out，buf）；}其他的{输出=strdup（buf）；if（！out）返回IDNA_MALLOC_ERROR；}开始=结束+1；}while（*结束）；*输出=输出；返回IDNA_SUCCESS；}

整数tld_get4（常量uint32_t*输入，大小_输入，字符**输出）{const uint32_t*首次公开募股；size_tolen；*输出=空；if（！in输入==0）返回TLD_NODATA；ipos=在[inlen-1]中；olen=0；/*向后扫描非（拉丁）字母*/而（ipos>=in&&（（*ipos>=0x41&&*ipos<=0x5A）||（*首次公开募股>=0x61&&*首次公开招股<=0x7A））首次公开募股——，olen++；如果（olen>0&&ipos>=在&&DOTP中（*ipos））{/*找到了一个TLD*/char*out_s=malloc（sizeof（char）*（olen+1））；char*opos=输出s；if（！opos）返回TLD_MALLOC_ERROR；ipos++；/*将ascii字符串转换为小写*/对于（；ipos<&in[inlen]；ipos++，opos++）*opos=*ipos>0x5A*首次公开募股：*ipos+0x20；*opos=0；*out=out_s；返回TLD_SUCCESS；}返回TLD_NO_TLD；}

静态intidna_to_ unicode_ internal（字符*utf8in，uint32_t*out，size_t*outlen，int标志）{整数rc；char tmpout[64]；size_t utf8len=字符串（utf8in）+1；size_t addlen=0，addinc=utf8len/10+1；/**ToUnicode由以下步骤组成：** 1. 如果序列包含ASCII范围之外的任何代码点*（0..7F）然后继续执行步骤2，否则跳至步骤3。*/{大小_ i；int-inasciirange；inasciirange=1；对于（i=0；utf8in[i]；i++）if（utf8in[i]和~0x7F）inasciirange=0；if（inasciirange）转到步骤3；}/** 2. 执行[NAMEPREP]中指定的步骤，如果存在*错误。（如果此处也执行ToASCII的步骤3，则不会*影响ToUnicode的整体行为，但不是*必要的。）[NAMEPREP]中使用了AllowUnassigned标志。*/做{char*newp=重新分配（utf8in，utf8len+addlen）；if（newp==NULL）{自由（utf8in）；返回IDNA_MALLOC_ERROR；}utf8in=新p；if（标志&IDNA_ALLOW_UNASSIGNED）rc=字符串rep_nameprep（utf8in，utf8len+addlen）；其他的rc=字符串rep_nameprep_no_unassigned（utf8in，utf8len+addlen）；addlen+=附加；addinc*=2；}而（rc＝＝STRINGPREP_TOO_MALL_BUFFER）；if（rc！=字符串PREP_OK）{自由（utf8in）；返回IDNA_STRINGPREP_ERROR；}/* 3. 验证序列是否以ACE前缀开头，并保存*序列的副本。* ... ToASCII和ToUnicode操作必须识别ACE前缀区分大小写。*/步骤3：if（c_strncasemp（utf8in，IDNA_ACE_PREFIX，strlen（IDNA_ACE _PREFIX））！=0){自由（utf8in）；返回IDNA_NO_ACE_PREFIX；}/* 4. 删除ACE前缀。*/内存移动（utf8in，&utf8in[strlen（IDNA_ACE_PREFIX）]，strlen（utf8in）-strlen（IDNA_ACE_PREFIX）+1）；/* 5. 使用[PUNYCODE]中的解码算法对序列进行解码*如果出现错误，则失败。保存结果的副本*这一步。*/（*外）--；/*为零保留一个*/rc=punycode_decode（字符串（utf8in），utf8in.，outlen，out，NULL）；如果（rc！=PUNYCODE_SUCCESS）{自由（utf8in）；返回IDNA_PUNYCODE_ERROR；}out[*outlen]=0；/*加零*//* 6. 应用到ASCII。*/rc=idna_to_ascii_4i（out，*outlen，tmpout，flags）；如果（rc！=IDNA_SUCCESS）{自由（utf8in）；返回rc；}/* 7. 验证步骤6的结果是否与中保存的副本相匹配*步骤3，使用区分大小写的ASCII比较。*/if（c_strcasecmp（utf8in，tmpout+strlen（IDNA_ACE_PREFIX））！=0){自由（utf8in）；返回IDNA_ROUNDTRIP_VERIFY_ERROR；}/*8。从步骤5返回保存的副本。*/自由（utf8in）；返回IDNA_SUCCESS；}

静态gboolean组合（gunichar a，gunichars b，gunichar*result）{涌出指数a，指数b；if（组合汉古尔语（a，b，result））返回TRUE；索引a=复合索引（a）；如果（index_a>=COMPOSE_FIRST_SINGLE_START&&index_a<COMPOSE_SECOND_START）{如果（b==作曲首单[index_a-COMOSE_first_single_START][0]）{*结果=作曲第一首单曲[索引_a-作曲_first_single_START][1]；返回TRUE；}其他的返回FALSE；}index_b=复合索引（b）；如果（index_b>=复合秒单启动）{如果（a）==compose_second_single[索引_b-组合_second_single_START][0]）{*结果=compose_second_single[1]；返回TRUE；}其他的返回FALSE；}如果（index_a>=复合_FIRST_START&&index_a<COMPOSE_FIRST_SINGLE_START&&index_b>=复合_秒_开始&&索引_b<复合_秒_单_星）{古尼查雷=合成数组[index_a-合成_FIRST_START][index_b-复合_秒_开始]；if（res）{*结果=res；返回TRUE；}}返回FALSE；}

静态gunichar*g_utf8_to_ucs4_fast（const gchar*str，glong len，glong*items_writed）{gunichar*结果；g大小n字符，i；常量gchar*p；g_return_val_if_fail（str！=空，空）；p=str；n_chars=0；如果（长度<0）{while（*p）时{p=g_utf8_next_char（p）；++n字符；}}其他的{while（p<str+len&&*p）{p=g_utf8_next_char（p）；++n字符；}}结果=g_malloc（sizeof（gunichar）*（n_chars+1））；if（！result）返回NULL；p=str；对于（i=0；i<n_chars；i++）{gunichar wc=（guchar）*p++；如果（wc<0x80）{结果[i]=wc；}其他的{gunichar掩码=0x40；if（G_UNLIKELY（（wc&mask）==0））{/*它是一个无序的10xxxxxxx字节。*而不是对这个字节和下一个字节进行丑陋的散列*并且溢出缓冲区，处理它更有用*带有替换字符*/结果[i]=0xfffd；继续；}做{wc<<=6；wc |=（guchar）（*p++）&0x3f；掩码<<=5；}while（（wc&mask）！=0);wc&=掩码-1；结果[i]=wc；}}结果[i]=0；如果（items_writted）*items_writed=i；返回结果；}

静态int_tld_checkchar（uint32_t ch，常量tld_table*tld）{常数Tld_table_element*s，*e，*m；if（！tld）返回TLD_SUCCESS；/*检查[-a-z0-9.]*/如果（（ch>=0x61&&ch<=0x7A）||（ch>=0x30&&ch<=0x39）||ch==0x2D||DOTP（ch））返回TLD_SUCCESS；s=tld->有效；e=s+tld->无效；而（s<e）{m=s+（（e-s）>>1）；if（ch<m->开始）e=米；否则，如果（ch>m->end）s=m+1；其他的返回TLD_SUCCESS；}返回TLD_INVALID；}