狠狠色丁香婷综合久久,久久精品无码专区免费东京热,久久综合久久综合九色

��字�W�串按“，”分�?lua函数)

swo — Tue, 05 Dec 2006 02:10:00 GMT

Version 3.69 of MUSHclient adds a new Lua script function: utils.split. This was suggested by Ked.

This is intended to do the reverse of table.concat. That is, it takes a string and generates a table of entries, delimited by single-character delimiters (such as comma or newline).

Example:


test = "the,quick,brown,dog,jumped"  

t = utils.split (test, ",")

tprint (t)

print (table.concat (t, ","))

Output:

1="the"
2="quick"
3="brown"
4="dog"
5="jumped"

the,quick,brown,dog,jumped

You pass utils.split 2 or 3 arguments:

The string to be split
The single-character delimiter
(optional) the maximum number of splits to do

If the 3rd argument is not supplied, or is zero, then the entire string is split. Otherwise, it will be split the number of times you specify. eg.


t = utils.split (test, ",", 2)

tprint (t)

Output:

1="the"
2="quick"
3="brown,dog,jumped"

In this case the remaining text is placed in the 3rd table item.

static int l_split (lua_State *L) {
  const char *s = luaL_checkstring(L, 1);
  const char *sep = luaL_checkstring(L, 2);
  const int count = (int) luaL_optnumber (L, 3, 0);
  char *e;
  int i = 1;

  if (strlen (sep) != 1)
    luaL_error (L, "Separator must be a single character");

  if (count < 0)
    luaL_error (L, "Count must be positive or zero");

  lua_newtable(L);  /* result */

  /* repeat for each separator */
  while ((e = strchr(s, *sep)) != NULL && 
         (count == 0 || i <= count)) 
    {
    lua_pushlstring(L, s, e-s);  /* push substring */
    lua_rawseti(L, -2, i++);
    s = e + 1;  /* skip separator */
    }

  /* push last substring */
  lua_pushstring(L, s);
  lua_rawseti(L, -2, i);

  return 1;  /* return the table */
}

function split (s, delim)

  assert (type (delim) == "string" and string.len (delim) > 0,
          "bad delimiter")

  local start = 1
  local t = {}  -- results table

  -- find each instance of a string followed by the delimiter

  while true do
    local pos = string.find (s, delim, start, true) -- plain find

    if not pos then
      break
    end

    table.insert (t, string.sub (s, start, pos - 1))
    start = pos + string.len (delim)
  end -- while

  -- insert final one (after last delimiter)

  table.insert (t, string.sub (s, start))

  return t

end -- function split

swo 2006-12-05 10:10 发表评论

Lua的多��d��机制——协�E?coroutine)

swo — Wed, 29 Nov 2006 06:30:00 GMT

�q�发是现实世界的本质特征�Q�而聪明的计算机科学家用来模拟�q�发的技术手�D�便是多��d��机制。大致上有这么两�U�多��d��技术，一�U�是抢占式多��d�� (preemptive multitasking)�Q�它让操作系�l�来军_��何时执行哪个��d��。另外一�U�就是协作式多�Q�?cooperative multitasking)�Q�它把决定权交给��d��Q�让它们在自��p��为合适的时候自愿放弃执行。这两种多�Q务方式各有优�~�点�Q�前者固有的同步问题使得�E�序�l? 常有不可预知的行为，而后者则要求��d��具备相当的自律精��?br />　　　　协程(coroutine)技术是一�U�程序控制机�Ӟ��早在上世�U?0�q�代��已提出�Q�用它可以很方便地实现协作式多�Q务。在��L��的程序语�a�(如C++、Java、Pascal�{?里我们很��能看到协程的��n影，但是现在不少动态脚本语 �a�(Python、Perl)却都提供了协�E�或与之�怼�的机�Ӟ��其中最�H�出的便是Lua�?br />　　
　　　　Lua语言实现的协�E�是一�U�非对称 �?asymmetric)协程�Q�或�U�半对称�?semi-asymmetric)协程�Q�又或干脆就叫半协程(semi-coroutine)。这�U�协�E? 机制之所以被�U�Cؓ非对�U�的�Q�是因�ؓ它提供了两种传递程序控制权的操作：一�U�是(�?调用协程(通过coroutine.resume)�Q�另一�U�是挂�v协程 �q�将�E�序控制权返回给协程的调用�?通过coroutine.yield)。一个非对称协程可以看做是从属于它的调用者的�Q�二者的关系非常�c�M��于例�E? (routine)与其调用者之间的关系。既然有非对�U�式协程�Q�当然也��有对称�?symmetric)协程了，它的特点是只有一�U�传递程序控制权的操作，卛_��控制权直接传递给指定的协�E�。曾�l�有�q�么一�U�说法，对称式和非对�U�式协程机制的能力�ƈ不等��P��但事实上很容易根据前者来实现后者。接下来我们��q�� 代码来证明这个事实�?br />　　
　　--对称式协�E�库coro.lua
　　
　　coro = {}
　　--coro.main用来标识�E�序的主函数
　　coro.main = function() end
　　-- coro.current变量用来标识拥有控制权的协程�Q?br />　　-- 也即正在�q�行的当前协�E?br />　　coro.current = coro.main
　　
　　-- 创徏一个新的协�E?br />　　function coro.create(f)
　　　 return coroutine.wrap(function(val)
　　　　　　　　　　　　　　　　return nil,f(val)
　　　　　　　　　　　　　　 end)
　　end
　　
　　-- 把控制权及指定的数据val传给协程k
　　function coro.transfer(k,val)
　　　 if coro.current ~= coro.main then
　　　　　return coroutine.yield(k,val)
　　　 else
　　　　　-- 控制权分�z��@�?br />　　　　　while k do
　　　　　　 coro.current = k
　　　　　　 if k == coro.main then
　　　　　　　　return val
　　　　　　 end
　　　　　　 k,val = k(val)
　　　　　end
　　　　　error("coroutine ended without transfering control...")
　　　 end
　　end
　　
　　如果暂时�q�弄不懂上面的程序，没关�p�，看看如何使用�q�个库后再回头分析。下面是使用�C�Z��Q?br />　　
　　require("coro.lua")
　　
　　function foo1(n)
　　　 print("1: foo1 received value "..n)
　　　 n = coro.transfer(foo2,n + 10)
　　　 print("2: foo1 received value "..n)
　　　 n = coro.transfer(coro.main,n + 10)
　　　 print("3: foo1 received value "..n)
　　　 coro.transfer(coro.main,n + 10)
　　end
　　
　　function foo2(n)
　　　 print("1: foo2 received value "..n)
　　　 n = coro.transfer(coro.main,n + 10)
　　　 print("2: foo2 received value "..n)
　　　 coro.transfer(foo1,n + 10)
　　end
　　
　　function main()
　　　 foo1 = coro.create(foo1)
　　　 foo2 = coro.create(foo2)
　　　 local n = coro.transfer(foo1,0)
　　　 print("1: main received value "..n)
　　　 n = coro.transfer(foo2,n + 10)
　　　 print("2: main received value "..n)
　　　 n = coro.transfer(foo1,n + 10)
　　　 print("3: main received value "..n)
　　end
　　
　　--把main设�ؓ��d��?协程)
　　coro.main = main
　　--��coro.main设�ؓ当前协程
　　coro.current = coro.main
　　--开始执行主函数(协程)
　　coro.main()
　　
　　
　　上面的示例定义了一个名为main的主函数�Q�整个程序由它而始�Q�也因它而终。�ؓ什么需要一个这��L��d��数呢�Q�上面说了，�E�序控制权可以在对称式协�E�之�? 自由地直接传递，它们之间无所谓谁从属于谁的问题，都处于同一个层�U�，但是应用�E�序必须有一个开始点�Q�所以我们定义一个主函数�Q�让它点燃程序运行的导火 �Uѝ��虽说各个协�E�都是��^�{�的�Q�但做�ؓ�E�序�q�行原动力的��d��C��然��n有特�D�的��C��(�q�个世上哪有�l�对的��^�{�！)�Q��ؓ此我们的库专门用了一�? coro.main变量来保存主函数�Q��ƈ且在它执行之前要��它设�ؓ当前协程(虽然上面的main实际只是一个普通函数而非一个真正的协程�Q�但�q��ƈ无太大的关系�Q�以后主函数也被�U�Cؓ��d��E?。示例运行的�l�果是：
　　
　　1: foo1 received value 0
　　1: foo2 received value 10
　　1: main received value 20
　　2: foo2 received value 30
　　2: foo1 received value 40
　　2: main received value 50
　　3: foo1 received value 60
　　3: main received value 70
　　
　　协程的执行序列是�Q�main->foo1->foo2->main->foo2->foo1->main->foo1->main�?br />　　
　　　　coro.transfer(k,val)函数中k是将要接收程序控制权的协�E�，而val是传递给k的数据。如果当前协�E�不是主协程�Q? tansfer(k,val)��q��单地利用coroutine.yield(k,val)��当前协�E�挂起�ƈ传回两项数据�Q�即�E�序控制权的下一站和传递给�? 的数据；否则�q�入一个控制权分派(dispatch)循环�Q�该循环(�?启动(resume)k协程�Q�等待它执行到挂�?suspend)�Q��ƈ�Ҏ(gu��)��此时�? �E�传回的数据来决定下一个要(�?启动的协�E�。从应用�C�Z��来看�Q�协�E�与协程之间��g��是用transfer直接传递控制权的，但实际上�q�个传递还是通过了主协程。每一个在��d��E�里被调�?比较coro.current和coro.main是否相同卛_��判断�?的transfer都相当于一个协�E�管理器�Q�它�? 断地(�?启动一个协�E�，��控制权交出去，然后�{�那个协�E�挂��h��又将控制权收回，然后�?�?启动下一个协�E?..�Q�这个动作不会停止，除非< 1>��?�?启动的协�E�是��d��E�；<2>某个协程没有提供控制权的下一个目的地。很昄��Q�每一轮分�z��@环开始时都由��d��E�把握控制权�Q? 在��@环过�E�中如果控制权的下一站又是主协程的话��意味着�q�个当初把控制权交出�ȝ��d��E�transfer操作应该�l�束了，所以函数直接返回val从而结�? �q�轮循环。对于情�?lt;2>�Q�因为coro.create(f)创徏的协�E�的体函�?body function)实际是function(val) return nil,f(val) end�Q�所以当函数f的最后一条指令不是transfer�Ӟ��q�个协程�l�将执行完毕�q�把nil和函数f的返回��g��赯��回。如果k是这��L��协程�Q? transfer执行完k,val = k(val)语句后k值就成了nil�Q�这被视��Z��个错误，因�ؓ�E�序此时没法��定下一个应�?�?启动的协�E�到底是谁。所以在对称式模型下�Q�每一个协�E?�? 然主协程出外)最后都必须昑ּ�地将控制权传递给其它的协�E�。根据以上分析，应用�C�Z��的控制权的分�z�ֺ�为：
　　
　　�W�一轮分�z? main->foo1->main->foo2->main->main(�l�束)
　　�W�二轮分�z? main->foo2->main->foo1->main->main(�l�束)
　　�W�三轮分�z? main->foo1->main->main(�l�束)
　　
　　　　�׃��可以直接指定控制权传递的目标�Q�对�U�式协程机制拥有极大的自由，但得到这�U�自��q��代�h(hu��n)却是牺牲�E�序�l�构。如果程序稍微复杂一点，那么即��是非�? 有经验的�E�序员也很难对程序流�E�有全面而清晰的把握。这非常�c�M��goto语句�Q�它能让�E�序跌��{��C�Q何想�ȝ��地方�Q�但��Z��却很隄��解充斥着goto的程序�? 非对�U�式协程��h��良好的层�ơ化�l�构关系�Q?�?启动�q�些协程与调用一个函数非常类��|��?�?启动的协�E�得到控制权开始执行，然后挂�v(或结�?�q�将控制权返回给协程调用者，�q�与计算机先哲们倡导的结构化�~�程风格完全一致�?br />　　
　　　　�l�g��所�q�ͼ�Lua提供的非对称式协�E�不但具有与对称式协�E�一样强大的能力�Q�而且�q�能避免�E�序员滥用机制写出结构�؜��q��E�序�?img src ="http://www.shnenglu.com/swo2006/aggbug/15781.html" width = "1" height = "1" />

swo 2006-11-29 14:30 发表评论

fuction(lua)

swo — Tue, 28 Nov 2006 06:43:00 GMT

Lua中的函数是一阶类型�?first-class value)�Q�定义函数就象创建普通类型��g��?只不�q�函数类�?/font> 值的数据主要是一条条指��o而已)�Q�所以在函数体中仍然可以定义函数。假讑և�数f2定义在函数f1中，那么��q�� f2为f1的内�?inner)函数�Q�f1为f2的外�?enclosing)函数�Q�外包和内嵌都具有传递性，即f2的内嵌必然是 f1的内嵌，而f1的外包也一定是f2的外包。内嵌函数可以访问外包函数已�l�创建的所有局部变量，�q�种�Ҏ(gu��)��便�?/font> 所谓的词法定界(lexical scoping)�Q�而这些局部变量则�U�Cؓ该内嵌函数的外部局部变�?external local variable)或者upvalue(�q�个词多��会让�h产生误解�Q�因为upvalue实际指的是变量而不是�?。试看如下代码：

function f1(n)
-- 函数参数也是局部变�?/font>

   local function f2()
      print(n) -- 引用外包函数的局部变�?/font>
   end
   return f2
end

g1 = f1(1979)
g1() -- 打印�?979
g2 = f1(500)
g2() -- 打印�?00

当执行完g1 = f1(1979)后，局部变量n的生命本该结束，但因为它已经成了内嵌函数f2(它又被赋�l�了变量 g1)的upvalue�Q�所以它仍然能以某种形式�l�箋“存�z�Z��下来，从而��og1()打印出正��的倹{�?/font>

可�ؓ什么g2与g1的函��C��一�?都是f1的内嵌函数f2的函��C��)�Q�但打印��g��同？�q�就涉及��C��个相当重�?/font> 的概念——闭�?closure)。事实上�Q�Lua�~�译一个函数时�Q�会为它生成一个原�?prototype)�Q�其中包含了函数体对应的虚拟机指令、函数用到的帔R��?敎ͼ�文本字符串等�{?和一些调试信息。在�q�行�Ӟ��每当Lua执行一个�Ş如function...end �q�样的表辑ּ��Ӟ��它就会创��Z��个新的数据对象，其中包含了相应函数原型的引用、环�?environment�Q�用来查扑օ�局变量的表)的引用以及一个由所有upvalue引用�l�成的数�l�，而这个数�?/font> 对象��q��为闭包。由此可见，函数是编译期概念�Q�是静态的�Q�而闭包是�q�行期概念，是动态的。g1和g2的��g��?/font> 来说不是函数而是闭包�Q��ƈ且是两个不相同的闭包�Q�而每个闭包可以保有自��q��upvalue��|��所以g1和g2打印�?/font> 的结果当然就不一样了。虽焉��包和函数是本质不同的概念�Q�但��Z��方便�Q�且在不引�v��h��的情况下�Q�我们对�?/font> 们不做区分�?/font>

使用upvalue很方便，但它们的语义也很微妙�Q�需要引��h��意。比如将f1函数�Ҏ(gu��)��Q?/font>

function f1(n)
   local function f2()
      print(n)
   end
   n = n + 10
   return f2
end

g1 = f1(1979)
g1() -- 打印�?989

内嵌函数定义在n = n + 10�q�条语句之前�Q�可��Z��么g1()打印出的却是1989�Q�upvalue实际是局部变量，�?/font> 局部变量是保存在函数堆栈框架上(stack frame)的，所以只要upvalue�q�没有离开自己的作用域�Q�它?y��u)�׃��?/font> 生存在函数堆栈上。这�U�情况下�Q�闭包将通过指向堆栈上的upvalue的引用来讉K��它们�Q�一旦upvalue卛_��d�� 自己的作用域(�q�也意味着它马上要从堆栈中消失)�Q�闭包就会�ؓ它分配空间�ƈ保存当前的��|��以后便可通过指向新分配空间的引用来访问该upvalue。当执行到f1(1979)的n = n + 10�Ӟ��闭包已经创徏了，但是n�q�没有离开作用域，所以闭包仍然引用堆栈上的n�Q�当return f2完成�Ӟ��n卛_��l�束生命�Q�此旉��包便��n(已经�?989 �?复制到自��q��理的�I�间中以便将来访问。弄清楚了内部的�U�密后，�q�行�l�果��׃��难解释了�?/font>

upvalue�q�可以�ؓ闭包之间提供一�U�数据共享的机制。试看下例：

function Create(n)
   local function foo1()
      print(n)
   end

   local function foo2()
      n = n + 10
   end

return foo1,foo2
end

f1,f2 = Create(1979)
f1() -- 打印1979
f2()
f1() -- 打印1989
f2()
f1() -- 打印1999

f1,f2�q�两个闭包的原型分别是Create中的内嵌函数foo1和foo2�Q�而foo1和foo2引用的upvalue是同一个，即Create的局部变量n。前面已说过�Q�执行完Create调用后，闭包会把堆栈上n的值复制出来，那么是否f1和f2 ��分别拥有一个n的拷贝呢�Q�其实不�Ӟ��当Lua发现两个闭包的upvalue指向的是当前堆栈上的相同变量�Ӟ��会聪明地只生成一个拷贝，然后让这两个闭包�׃�n该拷贝，�q�样��M��个闭包对该upvalue�q�行修改都会被另一个探�?/font> 。上�q�C��子很清楚地说明了�q�点�Q�每�ơ调用f2都将upvalue的值增加了10�Q�随后f1��更新后的值打印出来�?/font> upvalue的这�U�语义很有�h(hu��n)��|��它��得闭包之间可以不依赖全局变量�q�行通讯�Q�从而��代码的可靠性大大提高�?/font>

闭包在创��Z��时其upvalue��已�l�不在堆栈上的情况也有可能发生，�q�是因�ؓ内嵌函数可以引用更外层外包函�?/font> 的局部变量：

function Test(n)
   local function foo()
      local function inner1()
         print(n)
      end
      local function inner2()
         n = n + 10
      end
      return inner1,inner2
   end
   return foo
end

t = Test(1979)
f1,f2 = t()
f1()        -- 打印1979
f2()
f1()        -- 打印1989
g1,g2 = t()
g1()        -- 打印1989
g2()
g1()        -- 打印1999
f1()        -- 打印1999

执行完t = Test(1979)后，Test的局部变量n��“死”了�Q�所以当f1,f2�q�两个闭包被创徏时堆栈上�Ҏ(gu��)��找不�?/font> n的踪影，�q�叫它们如何取得n的值呢�Q�呵呵，不要忘了Test函数的n不仅仅是inner1和inner2的upvalue�Q�同时它也是foo的upvalue。t = Test(1979)之后�Q�t�q�个闭包一定已�l�把n妥善保存好了�Q�之后f1、f2如果�?/font> 当前堆栈上找不到n��׃��自动到它们的外包闭包(姑且�q�么�?的upvalue引用数组中去找，�q�把扑ֈ�的引用值拷贝到自己的upvalue引用数组中。仔�l�观察上�q�C��码，可以判定g1和g2与f1和f2�׃�n同一个upvalue。这是�ؓ 什么呢�Q�其实，g1和g2与f1和f2都是同一个闭�?t)创徏的，所以它们引用的upvalue(n)实际也是同一个变�?/font> �Q�而刚才描�q�的搜烦机制则保证了最后它们的upvalue引用都会指向同一个地斏V�?/font>

Lua��函数做为基本类型值�ƈ支持词法定界的特性��得语�a��h��强大的抽象能力。而透彻认识函数、闭包和 upvalue��帮助程序员善用�q�种能力�?/font>

swo 2006-11-28 14:43 发表评论

狠狠色丁香婷综合久久,久久精品无码专区免费东京热,久久综合久久综合九色

���字�W�串按“，”分�?lua函数)

Lua的多��d��机制——协�E?coroutine)

fuction(lua)

��字�W�串按“，”分�?lua函数)