요근래 어플리케이션을 확장하고 수정하기 위한 여러개의 소형 언어들이 제안되어져 왔다. 일반적으로 이런 확장 언어들은 다음과 같은 특징을 가지고 있다.

• 명백하고 간단한 문법 (이런 언어의 대부분의 사용자들에게는 주력 언어가 아니기때문이다)
• 작은 크기와 쉬운 구현 (고로 원래 프로그램에 추가하는 비용이 그렇게 높지 않다)
• 좋은 데이타 묘사 기능 (설정 언어로써 유용하게 사용될 수 있다)
• 알맞은 확장성 (높은 추상화 레벨상에서 사용가능할 것 - 다른 분야의 사용자들도 사용할 수 있게 하기 위함)
  
  

확장 언어들은 소프트웨어의 대부분을 기술하기위한 것은 아니기 때문에, 광범위한 프로그래밍을 지원하기 위한 구조 - 정적 타입 검사라던가 정보 은폐등등 - 은 필수적이지는 않다.

우리가 여기에 발표하는 루아(LUA) - 확장가능한 임베디드용 언어 - 는 다음과 같은 요구사항을 만족한다. 이 언어의 문법과 제어구조들은 간단하고 익숙한 구조이다. 루아는 작다 - 구현된 전체의 크기는 ANSI C코드로 6천줄이 채 되지않는다. 대부분의 절차적인 언어에 일반적으로 존재하는 기능들외에도, 루아를 강력한 상위레벨 확장가능한 언어로 만들어 주는 특별한 특징들을 가지고 있다.

• first-class 값으로써 함수들을 정의하고 관리하는 능력. 이것은 객체지향적인 기능들의 구현을 엄청나게 단순하게 해준다.
• 결합하기 쉬운 배열(Associative array) - 대부분의 데이타 컨테이너를 구현하는 강력한 언어 개념이다.
• Garbage collection. 메모리 할당 - 프로그램 에러들의 주된 원인 - 에 대한 명확한 관리의 필요를 없애준다.
• 대체 시스템(fallback) 구조. 언어의 문법구조의 확장을 가능하게 한다.
• 재귀(Reflexive) 기능. 높은 다형적인 부분의 생성을 가능하게 한다.
  
  

루아는 데이타 정의 기능을 사용한 절차적 프로그래밍을 지원하기 위한 다목적의 임베디드 프로그래밍 언어이다. 공용소유권(public domain)에 있지 않다 하더라도 (TeCGraf라는 회사가 저작권을 가지고 있다), 루아는 학술적이나 상업적인 목적 양쪽으로 자유롭게 사용할 수 있다. http://www.lua.org 배포본은 또한 수학(sin, cos등등), 입출력, 문자열 관리함수들에 대한 표준 라이브러리를 포함하고 있다. 이 부가적인 라이브러리들은 시스템에 1천줄가량의 코드를 추가한다. 또한 (배포본은) 디버거와 바이트코드들을 담고 있는 이식가능한 이진화일들을 생성할 수 있는 별도의 컴파일러를 포함하고 있다. 코드는 대부분의 ANSI C 컴파일러에서 수정없이 컴파일된다. gcc(AIX, IRIX, Linux, Solaris, SunOS, ULTRIX), Turbo C (DOS), Visual C++ (Windows 3.1/95/NT), Think C (MacOS), CodeWarrior (MacOS)들이 대표적인 사용가능한 컴파일러들이다.

프로그램과의 링크시 충돌을 피하기 위해 모든 외부 식별자(함수, 변수등등)들은 'lua'를 접두어로써 붙인다. yacc를 사용해 생성시킨 코드 조차도 이 조건을 맞추기 위해 sed 필터를 통해 통과시킨다. 따라서 다른 목적으로 yacc를 사용한 프로그램과도 루아를 링크시킬 수 있다.

루아는 주 어플리케이션과 링크되기위한 C 함수들의 조그마한 라이브러리로써 제공된다. 예를 들자면, 가장 작은 루아 클라이언트는 아래 소스와 같은 대화형의 독립적인 인터프리터라고 할 수 있다.

#include "lua.h"

int main()
{
 char line[BUFSIZ];
 while (fgets(line,sizeof(line),stdin)!=0)
   lua_dostring(line);
 return 0;
}

이 프로그램에서 함수 lua_dostring은 문자열에 담겨있는 코드를 인터프리터에 넘긴다. 루아 코드의 각 부분은 함수의 정의들과 문장들을 담고 있을 것이다. lua.h는 루아의 API를 정의하며, 30개가량의 함수들을 가지고 있다. lua_dostring외에도 루아코드가 담긴 화일로부터 인터프리팅하기위한 lua_dofile이 있고, 루아의 전역 변수들을 관리하기위한 lua_getglobal와 lua_setglobal가 있으며, lua_call은 루아 함수들을 호출할 수 있게 해준다. lua_register는 루아로부터 C 함수들을 억세스가능하게 만들어준다. 그외 기타등등이 있지만 생략한다.

루아는 다소 Pascal과 비슷한 문법을 가지고 있다. else들로 하여금 매달리게 되는 것을 피하기 위해 if나 while문과 같은 제어 구조들은 명백한 end로 끝난다.주석은 Ada에서 사용한 문법을 따른다 - "--"로 시작하며 그 효과는 줄의 끝까지 지속된다. 루아는 다중 대입문을 지원한다. 예를 들자면, x, y = y, x은 x와 y의 값을 바꾼다. 더욱이, 함수들은 여러개의 값을 반환할 수 있다.

루아는 동적으로 타입이 지정되는 언어이다. 이것은 값은 타입을 가지고 있지만 변수는 그렇지 않다는 것을 의미한다. 그래서 변수나 타입에 대한 선언이 없다.내부적으로 각 값은 그것의 타입을 식별하기위한 태그를 가진다, 태그는 내장된 함수타입과 함께 실행시에 질의될 수 있다.(?) 변수들은 타입이 없으며 어떤 타입의 값도 담을 수 있다. 루아의 garbage collection은 값들이 사용되고 있는지를 추적하며, 사용하고 있지 않다고 판단되면 해제시킨다.

루아는 nil, string), number, user data, 함수, 그리고 테이블 타입들을 제공한다. nil은 nil값에 대한 타입이다 - 이것의 주된 특성은 어떤 다른 값과도 다르다는 것이다. 예를 들자면 이것은 변수의 초기화 값으로 사용하기 좋다. number타입은 부동소수점 실수들을 대표한다. string은 문자열을 대표한다. user data 타입은 C에서 void* 포인터를 연상하면 된다. 그리고 루아 안에서 주 객체들을 대표한다. 모든 타입들이 유용하지만, 루아의 유연성은 function들과 table들에서 기인한다. 이것은 Lisp와 Scheme언어로부터의 다음과 같은 두가지의 핵심적인 교훈의 산물이다.

• Function(함수)들은 first-class 값이 되어야만 한다.
• 언어는 단 하나의, 강력하게 통합된 데이타 생성자를 가져야만 한다. (Lisp에서 list, 루아에서는 table)
  
  

루아에서의 함수 값은 변수들에 저장될 수 있고, 다른 함수들의 인자로써 전달될 수 있으며, 테이블에 저장될 수 있는 등 여러 용도로 사용된다.

루아에서 함수가 선언될 때 (아래 예제를 봐라), 함수 본체는 바이트코드들로 기컴파일되며, function 값을 생성한다. 이 값은 주어진 이름의 전역변수로 적용된다. 반면에 C 함수들은 알맞은 API의 호출에 의해 호스트 프로그램에 의해 제공된다. 루아는 호스트 프로그램에 의해 등록되어있지 않은 C 함수는 호출할 수 없다. 그러므로, 호스트 프로그램은 루아 프로그램이 무엇을 할 수 있는지 - 운영체계에 대한 어떤 잠재적으로 위험한 접근을 포함한 - 에 대한 완전한 제어권을 가지고 있다.

function map(list, func)
  local newlist = {}
  local i = 1
  while list[i] do
    newlist[i] = func(list[i])
    i = i+1
  end
  return newlist
end

루아에서 Table은 Lisp에서의 list에 해당한다 : 이것들은 강력한 자료구조 체계로써 사용된다. 루아의 Table은 결합된 배열(associative array)과 유사하다. Associative array들은 단지 number를 제외한 어떤 타입의 값으로도 인덱스될 수 있다. Associative array를 사용하여 구현하게 되면 많은 알고리즘들이 하찮게 되어버린다. 왜냐면 검색을 위한 자료구조나 알고리즘들이 언어에의해 명시적으로 제공되기 때문이다. 루아는 Associative array를 해쉬 테이블로써 구현한다.

Associative array를 구현하고 있는 다른 언어들과는 달리 루아에서의 Table은 변수명에 매여있지 않다. 대신, Table들은 일반적인 언어들상에서의 포인터와 같이 다루어질 수 있는 동적으로 생성된 객체들이다. 다르게 말하면, Table은 객체이지 값이 아니다. 변수들은 Table을 담을 수 없으며, 단지 그것들을 참조할 뿐이다. 대입, 인자 전달, 함수 반환값들은 언제나 사용되기 전에 생성되며, 그것은 또한 Table이 자유롭게 다른 Table을 참조하는 것을 허락한다. 그래서, 루아의 Table은 재귀적인 데이타 타입들을 나타내거나, 일반적인 그래프 구조를 생성하거나, 심지어 순환(cycle)과도 같이 사용될 수 있다.

Table은 인덱스로써 필드명을 사용함으로써 간단히 Record를 시뮬레이션 할 수 있다. 루아는 a["name"]에 대한 또다른 문법적인 표현으로써 a.name을 제공함으로써 이런 작업을 더 쉽게 만들 수 있다. Set(집합)은 그 요소들을 Table의 인덱스로써 저장함으로써 쉽게 구현될 수 있다. Table(그리고 물론 Set도)은 homogeneous할 필요가 없다 : 그것들은 동시에 모든 타입의 - Function과 Table을 포함한 - 값들을 저장할 수 있다.

루아는 Table을 생성하기 위한 특별한 종류의 표현으로써 생성자(constructor)를 제공한다. 이것은 list, array, record들을 초기화하는 것을 손쉽게 해준다. 아래 예제를 봐라. (a)에 있는 테이블 선언은 (b)와 동일하다.

(a)
     t = {}  -- 빈 table
     t[1] = i
     t[2] = i*2
     t[3] = i*3
     t[4] = i+j

     s = {}
     s.a = x   -- s["a"] = x 과 같은 표현.
     s.b = y

(b)
     t = {i, i*2, i*3, i+j}
     s = {a=x, b=y}

Sometimes you need finer control over the data structures you are building. 때때로 여러분이 구축하고 있는 자료구조들 위에 더 좋은 제어를 필요로 할 때가 있다. 조금만 일반적인 메타 구조들을 제공한다는 철학에 따라,루아는 사용자 정의 생성자(Constructor)를 제공한다. 이 생성자는 생성자명{...} 로 쓰여지며, 보다 직관적인 표현은 생성자명({...})으로 쓸 수 있다. 다른 말로 하자면, 이런 생성자의 형태로써, Table이 생성되고, 초기화되며, 함수에 인자로써 전달된다. 이 함수는 초기화가 필요할 때는 언제나 초기화할 수 있으며 호스트 프로그램에서도 이것이 가능하다. 이런 경우는 동적 타입 검사나, 빠진 필드의 초기화, 보조(auxiliary) 자료구조의 갱신이 될 수 있다. 사용자 정의된 생성자는 고 레벨의 추상화를 제공하는데 사용될 수 있다. 고로, 알맞은 정의를 가진 환경하에서 여러분은 window1=Window{x=200, y=300, color="blue"} 을 정의하고는 평범한 Table이 아닌 "윈도우"로써 간주할 수 있다. 게다가, 생성자들이 expression이기 때문에 생성자들은 좀더 복잡한 구조들을 선언적인 스타일 내에 표현하기위해 내장될(nested) 수 있다. 아래 예제를 보라.

S = Separator{
     drawStyle = DrawStyle{style = FILLED},
     material =  Material{
       ambientColor  = {0.377, 0.377, 0.377}, 
       diffuseColor  = {0.800, 0.771, 0.093}, 
       emissiveColor = {0.102, 0.102, 0.102},
       specularColor = {0.0, 0.0, 0.0}
     },

     transform = Transform{
       translation = {64.293, 20.206, 0.0}, 
       rotation    = {0.0, 0.0, 0.0, 0.0}
     },
     shape = Sphere{radius = 10.0}
   }

함수가 First-Class 값이기 때문에, Table 필드들은 함수들을 참조할 수 있다. 이것은 객체지향적 프로그래밍을 위한 하나의 단계이고, 메서드의 정의와 호출을 하기위한 더욱 단순한 문법에 의해 더 간단히 만들수 있다. 메서드 정의는 아래 예제의 (a)와 같이 쓰여질 수 있으며, 이것은 아래 예제의 (b)와 같다. 다른 말로 하자면 메서드를 정의하는 것은 self라고 불리는 숨겨진 첫번째 인자를 가진 함수를 정의하고 Table 필드에 함수를 저장하는 것과 같다.

(a)
     function object:method(params)
       ...
     end

(b)
     function object.method(self, params)
       ...
     end

메서드 호출은 호출객체명:메서드명(인자들)으로 기술되며, 이것은 호출객체명.메서드명(호출객체명,인자들)로 번역된다. 인자 self의 이름에서 추측할수 있듯이 메서드의 호출객체명이 메서드의 첫번째 인자로 전달된다.

이런 형태의 생성은 정보은폐를 지원하지 않는다. 따라서 순수파들은 (정확하게는) 객체지향의 중요한 부분을 빼먹었다고 주장할 수도 있다. 게다가, 루아는 클래스를 제공하지 않는다. 각 객체는 그 자신의 매서드처리된 테이블을 수반한다. 그럼에도 불구하고, 이런 형태의 생성은 극히 가볍고 상속(프로토타입 기반의 언어들에서는 일반적으로 지원된다. Self를 생각하면 된다)을 사용하면 클래스들은 시뮬레이트 될수 있다.

루아가 타입이 없는 언어이기 때문에 많은 비정상적인 실시간 이벤트들이 발생할 수 있다. : 산술 연산들이 비산술적인 연산자에 적용될 수 있으며, table이 아닌 값이 인덱싱되고, function 값이 아닌데도 호출될 수 있다. 타입이 존재하는 독립적인 언어들은 컴파일러에 의해 이런 상태들중 몇가지들이 표시된다. : 다른 것들은 실시간에 프로그램 실행이 취소되는 결과를 가져온다. 호스트 프로그램의 실행을 취소하는 것은 임베디드 언어로써는 무례한 짓이므로 임베디드 언어는 통상적으로 에러 핸들링을 위해 훅을 제공한다. 루아에서는 이런 훅들을 "fallback"이라고 부르며 엄밀하게는 에러 상태가 아닌 상태를 다루는데도 사용된다. 이런 상태들은 Table내의 존재하지 않는 필드를 억세스한다거나 garbage collection을 신호하는 것등등이 될수 있다. 루아는 기본 fallback 핸들러들을 제공하지만 여러분은 setfallback 내장함수를 사용하여 사용자 정의 fallback 핸들러를 설정할 수 있다. 이 setfallback 함수는 fallback 상태를 구별하기 위한 문자열(아래 표 참조)과 상태가 발생했을 경우 실행될 함수를 인자로 가진다. setfallback 함수는 이전의 fallback 함수를 반환하므로 필요하다면 fallback 핸들러들을 교체하는 것이 가능하다.

문자열	상태
"arith"	적법하지않은 연산자에서의 산술연산
"order"	부정확한 연산자에서의 순서 비교
"concat"	부정확한 연산자에서의 문자열 연결
"getglobal"	정의되지 않은 전역변수의 값을 읽는 중
"index"	테이블에 존재하지않는 인덱스의 값을 받는 중
"gettable"	테이블이 아닌데 인덱스의 값을 읽는 중
"settable"	테이블이 아닌데 인덱스의 값을 쓰는 중
"function"	함수가 아닌데 호출함
"gc"	각 테이블이 수집되는 것을 위한 garbage collection동안에 호출됨(Called during garbage collection for each table being collected)
"error"	심각한 에러가 발생했을 경우 호출됨

루아에서 fallback의 가장 흥미있는 사용 용도 중 하나는 상속의 구현이다. 간단한 상속은 객체로 하여금 특별히 그 객체의 "parent;"라고 불리는 객체안에서 존재하지 않는 필드의 값을 찾는 것을 허락한다. (이 필드는 메소드가 될수도 있다) 이 체계는 객체 상속의 한 종류이며, Smalltalk나 C++에서 적용된 더욱 전통적인 클래스 상속과는 대조된다. 루아내에서의 간단한 상속은 구현하는 하나의 방법은 별도의 필드 - 예를 들자면 "parent" - 내에 부모 객체를 저장하고 "index" fallback 함수를 설정하는 것이다. 아래 코드를 봐라.

function Inherit(t,f)
  if f == "parent" then  -- loop를 피하기 위한 것임
    return nil
  end
  local p = t.parent
  if type(p) == "table" then
    return p[f]
  else
    return nil
  end
end

setfallback("index", Inherit)

이 코드는 Inherit함수를 정의하고 그것을 "index" fallback함수로 설정한다. 루아가 객체안에 존재하지 않는 필드를 억세스하려고 할때마다, fallback 기능이 Inherit함수를 호출한다. 이 함수는 맨처음 Table 값을 담고 있는 parent필드를 객체가 가지고 있는지 검사한다. 만약 그렇다면, 부모 객체내의 원하는 필드를 억세스하는 것을 시도할 것이다. 만일 부모내에도 그 필드가 존재하지 않는다면 fallback은 자동적으로 다시 호출된다. 이 처리는 필드의 값을 찾거나 부모를 찾아가는 호출이 끝날때까지 "위쪽으로" 반복된다. 더 나은 성능이 필요하다면 같은 상속 체계가 루아의 API를 사용하여 C안에 구현되어질 수 있다.

인터프리팅 언어인 까닭에 루아는 몇가지 재귀적인 기능을 제공한다. 하나의 예는 function 타입이며 이것은 이미 언급했다. 또다른 강력한 재귀적인 함수들은 테이블위를 traverse하는 next, 모든 전역 변수들을 traverse하는 nextvar이다. next는 두개의 인자를 가지는데, 테이블과 테이블내의 인덱스이며, 몇가지 구현과는 독립적인 순서에서의 "다음" 인덱스를 반환한다.(테이블이 해쉬 테이블로 구현되어있다는 것을 회상해라) 그것은 또한 테이블내의 인덱스와 연관된 값을 반환한다. (루아의 함수들은 다수의 값을 반환할 수 있음을 상기해라) nextvar 함수는 비슷한 역할을 하지만 테이블의 인덱스들대신에 전역변수들을 traverse한다는 것만 다르다. 재귀를 사용한 흥미있는 예는 동적 타입지정이다. 이전에 알려주었듯이, 루아는 정적 타입지정이 없다. 어쨌거나 때때로 프로그램내에서 오동작을 방지하기 위해 주어진 값이 정확한 타입인지 검사하는 것은 쓸모있다. type을 사용하여 간단한 타입을 검사하는 것은 쉽다. 그러나 테이블에서는 반드시 모든 필드가 존재하는지 그리고 정확히 값이 채워졌는지 검사해야만 한다. 루아의 데이타 기술 능력을 사용해서, 타입을 기술하기 위해 값들을 사용할 수 있다. : 하나의 타입이 그자신의 이름에 의해 기술되었고, 테이블 타입은 필요한 타입으로 각 필드를 매핑한 테이블에 의해 기술되었다. (아래 참조).

TNumber="number"
TPoint={x=TNumber, y=TNumber}
TColor={red=TNumber, blue=TNumber, green=TNumber}
TRectangle={topleft=TPoint, botright=TPoint}
TWindow={title="string", bounds=TRectangle, color=TColor}

위와 같이 기술함으로써, 여러분은 값이 주어진 타입을 가지고 있는지 검사하는 단일한, 다형성의 함수를 작성할 수 있다. 아래 소스를 참조해라.

function checkType(d, t)
  if type(t) == "string" then
    -- t는 type의 이름이다.
    return (type(d) == t)
  else
    -- t이 Table이다. 고로 d도 또한 Table이 되어야만 한다.
    if type(d) ~= "table" then
      return nil
    else
      -- d도 또한 table이다. 그 필드들을 검사한다.
      local i,v = next(t,nil)
      while i do
        if not checkType(d[i],v) then
          return nil
        end
        i,v = next(t,i)
      end
    end
  end
  return 1
end

재귀기능은 그 자신의 환경을 조정하기 위한 프로그램을 허용한다. 예를 들어 하나의 프로그램이 또다른 조각의 코드를 실행하기위해 "보호된 환경"을 생성할 수 있다. 이런 상황은 인터넷으로 부터 호스트가 믿을 수 없는 코드를 실행하려 할 때 에이전트 기반의 어플리케이션에서 흔히 볼 수 있다. (예를 들자면, 실행 가능한 콘텐츠 - 자바와 같은 최신유행의 - 을 가진 웹 페이지를 들 수 있다.) 몇몇 확장 언어는 안전한 실행을 위한 특별한 기능지원을 제공해야만 한다. 그러나 루아는 이런 점을 지원하기 위해 언어 그 자체를 사용하기에는 충분히 유연하다고 할 수 있다. 아래 예제는 어떻게 전체 전역변수들을 테이블에 저장할 수 있는지 보여준다.

function save()
  -- 환경변수들을 담기 위한 테이블을 생성한다.
  local env = {}
  -- 가장 처음 변수와 그 값을 얻는다.
  local n, v = nextvar(nil)
  while n do
    -- 테이블에 전역변수를 저장한다.
    env[n] = v
    -- 다음 전역변수와 그 값을 얻는다.
    n, v = nextvar(n)
  end
  return env
end

비슷한 함수는 저장된 환경을 복구하는 것이다. 모든 함수들은 변수들에 대입된 first-class 값이기 때문에, 전역 변수 환경에서 함수를 제거하는 것은 하찮을 정도로 쉬운 일이다. 아래 예제는 보호된 환경설정내에서 약간의 코드를 실행하는 함수를 보여준다.

function runProtected(code)
  -- 현재 환경을 저장한다
  local oldenv = save()
  -- "위험한" 함수들을 지운다
  readfrom,writeto,execute = nil,nil,nil
  -- 신뢰되지 않은 코드를 실행한다
  dostring(code)
  -- 원래 환경들을 복구한다
  restore(oldenv)
end

루아의 자연스런 용도는 GUI의 설정이라고 할 수 있다. -- 이런 경우에는 객체(위젯)의 상속관계를 기술하고 사용자 기능을 그 객체들에게 바인딩하는 기능이 필요할 것이다. 루아는 이런 경우에 적합하다. 왜냐하면 간단하고, 강력하며, 확장가능한 구문을 가진 데이타 기술 체계가 결합되어있기 때문이다. 정말로, 우리는 루아를 가지고 몇가지의 UI 툴킷을 개발해왔다.

Tk가 다용도의 GUI 툴킷이라고 할지라도 Tcl은 모든 사람들이 만족할 수 있는 종류의 언어는 아니다. 우리는 Tcl의 대체수단으로 루아를 고려한 까닭에 우리는 루아로부터 Tk 위젯들을 억세스할 수 있도록 하는 Tk/Lua 바인딩을 구현하기로 결정했다.

가능한한 우리는 위젯명, 속성들, 명령들을 포함한 Tk의 철학을 유지했다. 모든 사람들은 존재하는 API를 개선하려고 시도하는 일이 얼마나 유혹적인지 알고 있다. 그러나 장기적인 견지에서 보면 기존 그대로 놔두는 것이 Tk 사용자들에게 더 좋다. 왜냐면 그들은 새로운 컨셉을 배우려고 하지 않기 때문이다. (이것은 우리에게도 좋다. 왜냐면 새로운 메뉴얼을 쓸 필요가 없기 때문이다!)

우리는 루아로 모든 Tk 위젯들을 매핑했다. 여러분은 루아의 Table 생성자를 사용하여 그 자신의 속성들을 기술하는 위젯을 생성한다. 예를 들어, 아래 예제는 버튼을 하나 만들고 그것을 b에 담는다. b는 이제 버튼을 대표하는 객체가 되었다.

b = button{ label = "Hello world!"
            command = "exit(0)"
          }

이렇게 정의한 이후에도, 여러분은 일반적인 루아 문법을 객체를 관리하는데 사용할 수 있다. 따라서, b.label="Hello world from Lua!" 대입문은 버튼의 레이블을 바꾸고 만약 화면에 이미 보이는 상태라면 그것의 내용을 업데이트 한다. 20문자로 한정된 텍스트 입력 위젯은 e=entry{width=20} 으로 생성될 수 있다. 화면의 윈도우에 이 위젯이 매핑된 이후에, e.current는 입력 위젯에 사용자가 입력한 내용이 담겨 있다. (Tcl/Tk내에 있는 전역변수를 사용하는 것 대신에, 우리는 위젯 값을 담기위한 "current" 필드를 사용한다) 위젯들은 윈도우에 자동적으로 매핑되지 않는다. Tk/Tcl 환경과는 달리, Tk/Lua에는 현재 윈도우에 대한 개념이 없다. 여러분은 다른 위젯들을 담기 위한 윈도우를 생성해야만 한다 (주 윈도우나 최상위 레벨의 위젯이 될 수 있다) 그리고, 확실하게 위젯들을 화면에 매핑시켜야만한다. 아래 예제를 봐라.

w = toplevel{b}
w:show()

이 방법에서는 사용자는 자유롭게 그들의 대화상자들, 심지어 상호 참조하는 위젯들을 기술할 수 있고, 그것들을 필요할 때마다 매핑하는 것이 가능하다. 우리는 또한 명시적으로 위젯들을 묶는 작업의 필요성을 제거했다. 왜냐하면, 묘사적인 관점에서의 레이아웃을 정의하는 것이 더 자연스럽기 때문이다. 따라서, 윈도우(주 윈도우나 최상위 윈도우)와 프레임 위젯들은 그들의 내용들을 자동적으로 묶는 Container로써 사용된다. 예를 들어, 아래 예제를 보면 두개의 바닥 버튼들을 가진 메세지를 보여주기 위한 코드임을 알 수 있다. 모든 일반 Tk 위젯들이외에, 우리는 또한 두개의 부가적인 캔버스들을 구현했다. 하나응 Xlib로의 단순화된 API로 사용되며, 또하나는 OpenGL에서 사용된다.

b1 = button{label="Yes", command="yes=1"}
b2 = button{label="No", command="yes=0"}
w  = toplevel{message{text="Overwrite file?"},
              frame{b1, b2; side="left"};
              side="top"
             }

거의 모든 함수들이 루아로 매핑된 이 라이브러리에 의해 제공된다. 그래서 여러분은 루아만을 사용하여 수정된 위젯들상의 직접적인 제어를 사용하는 세련된 비쥬얼한 프로그램들을 생성할 수 있다.

모든 Tk 위젯 명령들은 Tk/Lua에서는 객체 메서드로써 구현된다. 이들의 이름과 인자, 함수들은 미리 지정되어있다. 만일 lb가 리스트박스 위젯을 의미한다면, lb:insert("New item")는 리스트 박스에 "New item"을 추가하는 문장이다. (Tk의 insert명령) 반면에, 가장많이 사용되는 Tk 위젯 명령인 configure 는 더이상 필요하지않다. 왜냐하면 그 명령의 역할이 지금은 간단한 대입문들에 담겨져있기 때문이다.

최상위 주 위젯들은 윈도우 메니져로부터 메서드들을 상속한다. 만약 w가 윈도우를 나타낸다면, w:iconify()는 명령이 나타내는 의미대로 동작할 것이다.

Tk/Lua를 구현하는 것은 어렵지 않았다. Tcl/Tk로 C 인터페이스를 사용하면서, 우리는 서비스 제공자를 생성하고 루아로부터 억세스되도록 그것을 등록했다. 바인딩을 구현하는 루아코드는 이전에 언급한 index fallback을 사용한 객체지향적 접근을 사용했다. 각 위젯 인스턴스는 상속의 가장 꼭대기의 위젯 클래스를 가진 클래스 객체로부터 상속되었다. 이 클래스는 모든 위젯들에 의해 사용되는 아래 예제는 이 일반 클래스와 메서드들의 정의와 위젯에 focus를 설정하는 메서드를 보여준다. 이것은 또한 버튼 클래스 정의도 보여주고 있다.

widgetClass = {}
function widgetClass:focus()
 if self.tkname then
  tklua_setFocus(self.tkname)
 end
end

buttonClass = {
 parent = widgetClass,
 tkwidget = "button"
}

이제 알다시피, 각 위젯은 테이블 생성자와 같이 생성된다. 생성자는 인스턴스 클래스를 설정하고, 위젯을 생성하며, 그것을 전역 배열에 담는다. 어쨌거나, 우리는 또한 작은 트릭을 사용한다 - 신규 테이블을 반환하는 것을 대신에 생성자는 위젯의 위치를 number형의 ID로써 반환한다. (아래 예제를 봐라)

function button(self)
 self.parent = classButton
 tklua_ID = tklua_ID + 1
 tklua_IDtable[tklua_ID] = self
 return tklua_ID
end

따라서, 루아는 b.label과 같이 위젯을 인덱스하려고 시도할 때, fallback을 호출하게 된다. 왜냐하면 숫자들은 인덱스될 수 없기 때문이다. 이 트릭은 우리에게 위젯구문을 완전히 제어할 수 있게 해준다. 예를 들자면 b가 버튼이고(실제로, b는 ID를 담고있다) 여러분은 {{b.label = "New label,"}}}을 설정하면 fallback은 위젯을 갱신하기 위해 알맞은 서비스 명령을 호출할 책임이 따르게 된다. 아래 예제는 Tk/Lua의 "settable" fallback 함수이다.

function setFB(id, f, v)
 local h = tklua_IDtable[id]
 if h == nil then
  old_setFB(id,f,v)
  return
 end
 if h.tkname and h:isAttrib(f) then
  tklua_configure(h.tkname,f,v)
 end
 h[f] = v

end
old_setFB = setfallback("settable",setFB)

이 fallback은 테이블이 아닌 값을 인덱스시키려는 모든 시도가 있을대 마다 호출된다. 맨처음, 우리는 첫번째 인자가 적합한 위젯 ID에 해당하는 지 여부를 검사한다. 만약 적법하다면, 우리는 전역 배열을 억세스함으로써 위젯 테이블을 반환한다. 그렇지 않다면, 이전에 등록된 fallback으로 실행이 재빠르게 넘어간다.

tklua_IDtable 테이블상의 위젯들은 tkname이라 불리는, Tk 위젯의 이름을 담고 있는 내부적인 필드를 가지고 있다. 이 이름들은 Tk 명령들을 실행하기 위해 사용된다. 우리는 알맞은 Tk 위젯이 있는지와 인덱스 값이 적법한 Tk 속성인지를 검사한다. 만일 적법하다면, 우리는 서비스 제공자에서 위젯 속성을 변경하도록 요청한다. (등록된 tklua_configure C 함수를 호출함으로써 수행된다) h[f]=v 문장은 우리가 Tk 속성이외의 값을 담기위해 위젯 테이블을 사용할 수 있도록 보증한다. "gettable" fallback을 구현하는 것은 비슷하다. 두개의 fallback에 덧붙여, Tk/Lua는 또한 상속을 구현하기 위해 index fallback을 사용하며(예제 참조), "function" fallback은 위젯 명령이나 윈도우 메니져 명령들을 호출하기 위해 사용한다.

확장 언어들은 언제나 한가지 혹은 또다른 방법으로 번역된다. 간단한 확장 언어들은 소스코드로부터 직접적으로 번역될 수 있다. 반면에 임베디드 언어들은 일반적으로 복잡한 문법과 구문을 가진 강력한 프로그래밍 언어들이다. 임베디드 언어들을 위한 더욱 효과적인 구현 테크닉은 이미 표준화 되었다 : 언어의 목적에 맞게 가상머신을 디자인하고, 확장 프로그램들을 사용될 기계를 위한 바이트코드들로 컴파일하고, 바이트코드들을 번역하는 것에 의해 가상머신을 시뮬레이션한다. 우리는 루아를 구현하기 위해 이 복합 구조를 선택했다. 왜냐하면 의미와 문법 문석은 단지 한번 이루어지며, 그것은 보다 더 빠른 실행속도로 나타나기 때문이다. 또한, 그것은 확장 프로그램이 기컴파일된 바이트코드 형식내에서만 제공되는 것만을 허락하며, 더욱 빠른 로딩과 더욱 안전한 환경을 제공하게 된다.

code의 폰트가 수정된 fixedsys인가요? 한글이 다 깨지는것 같은데요? 222.110.63.92 2004-09-09T07:45:19

아닙니다. Lusida Console입니다. 전 잘보이는데... - redpixel 2004-09-09T11:20:31

문제의 폰트를 지우니 제대로 나오는군요. 지정폰트가 있는데 엄한것이 나오다니 IE 나빠요. - 203.229.151.196 2004-09-10T13:52:30