KR101129083B1 - 표현 그룹화 및 평가 - Google Patents

Abstract

장치는, 스타일 시트 컴파일러와 문서 프로세서를 구비한다. 스타일 시트 컴파일러는 스타일 시트에서의 표현들을 식별하도록 구성되어 있으며 상기 표현들을 표현하는 하나 이상의 표현 트리들을 발생시키도록 구성되어 있다. 하나 이상의 공통 노드들을 가진 표현들은 상기 공통 노드들을 표현하는 서브트리의 자식들로서 표현된다. 문서 프로세서는 문서 및 상기 표현 트리를 수신하도록 결합되어 있으며, 상기 하나 이상의 표현 트리들로 표현되어 있는 표현들을 상기 문서에 대하여 평가하도록 구성되어 있다.

스타일 시트, 데이터 구조, 컴파일, 인코딩, 문서 변환

Description

표현 그룹화 및 평가{EXPRESSION GROUPING AND EVALUATION}

본 발명은 XML(extensible markup language), SGML(standardized generalized markup language), 및 HTML(hypertext markup language)과 같은, 구조적 문서들과 데이터베이스들 및/또는 파일 시스템들의 비구조적 데이터 및 문서들을 프로세싱하고 변환하는 분야에 관한 것이다.

컴퓨터들 및 컴퓨터 스토리지가 유비쿼터스화되어 옴에 따라, 다양한 조직들이 보유하는 정보량은 급격하게 증가하여 왔다. 정보는 대개, 워드프로세서 문서들, 스프레드 시트 파일들, 데이터베이스들, pdf(portable document format) 문서들, (예를 들어, 다양한 그래픽 디스플레이 포맷들로 스캐닝된) 이미지 문서들, 플레인 텍스트 등과 같은, 다수의 상이한 형태들로 저장된다. 또한, 문서들은 SGML, HTML, XML 등과 같은 마크업 언어로도 저장될 수도 있다.

정보가 그만큼 많은 상이한 형태들을 가짐으로 인해, 조직내에서 뿐만 아니라 조직 외부에서의 정보 공유가 복잡해진다. 최근에는, XML이 컨텐츠를 문서들로 기술하고 비구조적 데이터 및/또는 문서들을 구조화하기 위한 표준으로서 부각되어 오고 있다. XML은 문서를 위한 마크업을 정의하기 위한 유동적이고, 확장 가능한 메커니즘을 제공함으로써, 마크업이, 기술되고 있는 정보에 대해 개별화될 수 있게 한다.

XML을 프로세싱하기 위한 수단으로서 구현되는 일 메커니즘이 XSL(extensible stylesheet language) 및 XSL을 사용해 기입된 스타일 시트들(stylesheets)이다. 스타일 시트들은 XML 문서들을 XML내에서 정의된 일 마크업 정의(또는 "어휘")로부터 다른 어휘로, XML 마크업으로부터 (플레인 텍스트, 워드프로세서, 스프레드 시트, 데이터베이스, pdf, HTML 등과 같은) 다른 구조적 또는 비구조적 문서 형태로, 또는 다른 구조적 또는 비구조적 문서 형태로부터 XML 마크업으로 변환하도록 기입될 수 있다. 따라서, 스타일 시트들은 문서의 구조를 문서의 저장된 형태로부터 소정 사용자에 의해 기대되는 형태로 변환하는 것에 의해 조직의 (상이한 다수 형태들의) 정보에 대한 액세스를 단순화하는데 사용될 수도 있다. 또한, 스타일 시트들의 다른 유형들(예를 들어, HTML에 대한 확장으로서 정의되는 캐스케이딩 스타일 시트들, 또는 CSS)도 존재한다.

통상적으로, 문서 변환 프로세스는 범용 컴퓨터(예를 들어, 문서 스토리지를 관리하는 서버, 사용자 머신 등)에서 실행 중인 소프트웨어에서 수행된다. 이러한 문서들의 액세스에서는 상당한 지연들이 경험되고 있다.

일 실시예에서, 장치는, 스타일 시트 컴파일러와 문서 프로세서를 구비한다. 스타일 시트 컴파일러는 스타일 시트에서의 표현들을 식별하도록 구성되어 있으며 상기 표현들을 표현하는 하나 이상의 표현 트리들을 발생시키도록 구성되어 있다. 하나 이상의 공통 노드들을 가진 표현들은 상기 공통 노드들을 표현하는 서브트리의 자식들로서 표현된다. 문서 프로세서는 문서 및 상기 표현 트리를 수신하도록 결합되어 있으며, 상기 하나 이상의 표현 트리들로 표현되어 있는 표현들을 상기 문서에 대하여 평가하도록 구성되어 있다.

다음의 상세한 설명은, 여기에서 간략하게 설명되는 첨부 도면들을 참조한다.

도 1은 컨텐츠 변환 어플라이언스의 일 실시예의 블록도이다.

도 2는 도 1에 나타낸 문서 프로세서의 일 실시예의 블록도이다.

도 3은 도 2에 나타낸 문서 프로세서 및 도 1에 나타낸 프로세서의 일부에 대한 일 실시예의 블록도로서, 그 사이의 통신 및 거기로의 입력들을 도시하는, 블록도이다.

도 4는 스타일 시트 컴파일레이션 및 표현 평가의 방법에 대한 일 실시예를 도시하는 흐름도이다.

도 5는 스타일 시트 컴파일러의 일 실시예의 연산을 도시하는 흐름도이다.

도 6은 스키마 컴파일러의 일 실시예의 연산을 도시하는 흐름도이다.

도 7은 도 2 및 도 3에 나타낸 파서(parser)의 일 실시예를 위한 입력 데이터 구조들 및 출력 데이터 구조들의 일 실시예를 도시하는 블록도이다.

도 8은, 노드 식별자들에 일련 번호들을 할당하기 위한, 도 7에 나타낸 파서의 일 실시예에 대한 연산을 도시하는 흐름도이다.

도 9는 도 2 및 도 3에 나타낸 표현 프로세서의 일 실시예를 위한 입력 데이 터 구조들 및 출력 데이터 구조들의 일 실시예를 도시하는 블록도이다.

도 10은 도 2 및 도 9에 나타낸 파싱-시간 표현 트리(parse-time expression tree)의 일 실시예의 블록도이다.

도 11은 표현 트리의 일부 및 거기에 대응되는 파싱-시간 표현 트리 엔트리들의 일례이다.

도 12A 및 도 12B는 구성 요소 시작 이벤트에 따른 표현 프로세서의 일 실시예에 대한 연산을 도시하는 흐름도이다.

도 13은 구성 요소 끝 이벤트(element end event)에 따른 표현 프로세서의 일 실시예에 대한 연산을 도시하는 흐름도이다.

도 14A 및 도 14B는 속성 명칭 이벤트(attribute name event)에 따른 표현 프로세서의 일 실시예에 대한 연산을 도시하는 흐름도이다.

도 15는 구성 요소 종료 이벤트(element close event)에 따른 표현 프로세서의 일 실시예에 대한 연산을 도시하는 흐름도이다.

도 16은 변환 엔진의 일 실시예에 대한 연산을 도시하는 흐름도이다.

도 17은 도 2 및 도 9에 나타낸 파싱-시간 표현 트리에 대한 다른 실시예의 블록도이다.

도 18은 도 17에 나타낸 소정 필드들을 위한 예시적 인코딩들을 도시하는 한 세트의 테이블들이다.

도 19A 및 도 19B는 구성 요소 시작 이벤트(element start event)에 따른 표현 프로세서의 일 실시예에 대한 연산을 도시하는 흐름도이다.

도 20은 구성 요소 끝 이벤트에 따른 표현 프로세서의 일 실시예에 대한 연산을 도시하는 흐름도이다.

도 21A 및 도 21B는 속성 명칭 이벤트에 따른 표현 프로세서의 일 실시예에 대한 연산을 도시하는 흐름도이다.

도 22A 및 도 22B는 텍스트 이벤트에 따른 표현 프로세서의 일 실시예에 대한 연산을 도시하는 흐름도이다.

도 23A 및 도 23B는 코멘트 이벤트(comment event)에 따른 표현 프로세서의 일 실시예에 대한 연산을 도시하는 흐름도이다.

도 24A 및 도 24B는 프로세싱 명령어 이벤트(processing instruction event)에 따른 표현 프로세서의 일 실시예에 대한 연산을 도시하는 흐름도이다.

본 발명에 대한 다양한 변경들 및 다른 형태들의 여지가 존재함에도 불구하고, 본 발명에 관한 구체적 실시예들이 도면들에 일례로써 도시되어 있으며 여기에서 상세하게 설명될 것이다. 그러나, 도면들 및 그에 대한 상세한 설명은 본 발명을 개시된 특정 형태로 한정하기 위한 것이 아니라, 오히려, 첨부된 청구항들에 의해 정의되는 본 발명의 정신 및 범위내에 해당되는 모든 변경들, 등가물들 및 대안들을 포함하기 위한 것이라는 것을 이해할 수 있어야 한다.

이제 도 1을 참조하면, 컨텐츠 변환 어플라이언스(10)에 대한 일 실시예의 블록도가 도시되어 있다. 도 1의 실시예에서, 컨텐츠 변환 어플라이언스(10)는 네트워크 인터페이스 회로(12), 프로세서들(14A 및 선택적인 14B)과 같은 하나 이상 의 프로세서들, 문서 프로세서(16) 및 메모리(18)를 포함할 수 있다. 네트워크 인터페이스 회로(12)는, 하나 이상의 네트워크 커넥션들을 통해, 네트워크 또는 네트워크들에 결합되어 있다. (도 1에 나타내지 않은) 다양한 컴퓨터 시스템들이 네트워크 또는 네트워크들에 결합될 수도 있다. 네트워크 인터페이스 회로(12)는 프로세서들(14A-14B)에도 결합되어 있다. 프로세서들은 메모리(18) 및, 이 또한 메모리(18)에 결합되어 있는 문서 프로세서(16)에 결합되어 있다. 도시된 실시예에서, 메모리(18)는 스타일 시트 컴파일러(20), 스키마 컴파일러(22), 하나 이상의 심볼 테이블들(24), 하나 이상의 파싱-시간 표현 트리들(26), 명령어 테이블(30), 여백 테이블(32;whitespace table), 문서 유형 정의(DTD) 테이블(34), 표현 리스트 테이블(36), 템플릿 리스트 테이블(38), 및 다양한 문서 프로세서 데이터 구조들(39)을 저장한다.

컨텐츠 변환 어플라이언스(10)는, 네트워크 커넥션들을 통해, 문서들에 적용될 스타일 시트들, 문서들에 적용될 스키마, 및/또는 (스타일 시트/스키마를 문서에 적용하기 위한 요청과 함께) 문서들 자체를 수신할 수 있다. 스타일 시트를 적용하기 위한 요청에 응답하여, 컨텐츠 변환 어플라이언스(10)는 스타일 시트를 문서에 적용하여, 네트워크를 통해 요청자에게 전송될 변환된 문서를 발생시킬 수 있다. 일부 실시예들에서, 컨텐츠 변환 어플라이언스(10)는 문서를 (예를 들어, SAX(simple application programming interface (API) for XML) 또는 DOM(document object model)과 같은 정의된 포맷으로) 파싱하기 위한 요청을 수신할 수도 있다. 스키마(또는 DTD)를 적용하기 위한 요청에 응답하여, 컨텐츠 변환 어플라이언 스(10)는 스키마 또는 DTD에 따라 문서를 평가할 수 있고 요청자에 대한 성공 메시지 또는 (실패의 지시를 가진) 실패 메시지를 발생시킬 수 있다.

일부 실시예들에서, 컨텐츠 변환 어플라이언스(10)는 XML 데이터베이스에 액세스하는데 사용될 XPath 표현을 수신할 수도 있다. 이런 실시예들에서, 표현은 (다음에서 좀더 상세하게 설명되는) 스타일 시트와 유사하게 컴파일링될 수 있고, 스타일 시트를 문서에 적용하는 것과 유사한 방식으로 XML 데이터베이스에 적용될 수 있다.

일반적으로, XML 문서는 계층적 트리 구조를 갖는데, 이 경우, 트리의 루트는 문서를 전체로서 식별하고 문서의 다른 각 노드는 루트의 후손(descendent)이다. 다양한 구성 요소들, 속성들, 및 문서 컨텐츠가 트리의 노드들을 형성한다. 구성 요소들은, 구성 요소들이 포함하고 있는 컨텐츠의 구조를 정의한다. 각각의 구성 요소는 구성 요소 명칭을 갖고, 구성 요소는, 각각이 구성 요소 명칭을 포함하는 시작 태그 및 끝 태그를 사용해 컨텐츠를 한정한다. 구성 요소는 다른 구성 요소들을, 컨텐츠의 구조를 추가적으로 정의할 수 있는 하부-구성 요소들(sub-elements)로서 가질 수도 있다. 또한, 구성 요소들은 (구성 요소 명칭에 수반되는 시작 태그에 포함되어 있는) 속성들을 포함할 수도 있는데, 이 속성들은 구성 요소 또는 구성 요소 컨텐츠의 구조에 관한 추가 정보를 제공하는 명칭/값 쌍들(name/value pairs)이다. XML 문서들은 XML 문서, 코멘트들 등을 판독 중인 애플리케이션으로 전달될 프로세싱 명령어들을 포함할 수도 있다. 여기에서 사용되는 바와 같이, "문서"라는 용어는, 컨텐츠를 해석하는데 사용될 수 있는 정의된 대 응 구조를 가진 임의의 컨텐츠를 언급한다. 컨텐츠는 (XML 문서, HTML 문서, pdf 문서, 워드 프로세싱 문서, 데이터베이스 등과 같은) 상당히 구조적인 형태일 수 있거나 (그 구조가, 예를 들어, 문자들의 스트림일 수 있는) 플레인 텍스트 문서만큼 단순할 수도 있다. 일반적으로, 문서의 "노드"는 구조적 정의 (예를 들어, XML의 구성 요소들 및/또는 속성들) 및/또는 문서 컨텐츠를 포함할 수 있다. 특정한 일 실시예에서는, 노드가 구성 요소들, 속성들, 프로세싱 명령어들, 코멘트들, 및 텍스트를 포함할 수도 있다.

XSLT 스타일 시트를 한 세트의 템플릿들로 볼 수도 있다. 각각의 템플릿은 (i) 소스 문서의 트리 구조에서 노드들을 선택하는 표현; 및 (ii) 소스 문서의 매칭 노드 각각을 위해 인스턴스화되어야 할 출력 문서 구조의 대응되는 부분을 특정하는 바디(body)를 포함할 수 있다. 소스 문서에 스타일 시트를 적용하는 단계는 소스 문서의 각 노드에 대한 매칭 템플릿을 찾아내려고 시도하는 단계, 및 매칭 템플릿의 바디를 출력 문서의 트리로 인스턴스화하는 단계를 구비할 수 있다. 템플릿의 바디는 (i) 출력 문서로 인스턴스화될 리터럴 컨텐츠(literal content); (ii) 매칭 노드들로부터 출력 문서로 복사될 컨텐츠의 선택; 및 (iii) 문장들의 결과가 출력 문서로 인스턴스화되는, 평가되어야 할 문장들 중 하나 이상을 포함할 수 있다. 인스턴스화될 컨텐츠 및 평가될 문장들 모두를, 템플릿에 매칭되는 노드들에서 수행될 "액션들"이라고 할 수도 있다. 템플릿의 바디는, 하나 이상의 노드들을 선택하고 선택된 노드들에 스타일 시트의 템플릿들이 적용되게 함으로써 템플릿들을 효과적으로 네스팅하는 표현을 포함하는 하나 이상의 "템플릿들 적용하기(apply templates)" 문장들을 포함할 수도 있다. 템플릿들 적용하기 문장에 대한 매칭이 발견되면, 결과적인 템플릿은 템플릿들 적용하기 문장을 포함하는 템플릿의 인스턴스 생성내에서 인스턴스화된다. 템플릿 바디의 다른 문장들은 노드들에 대하여 매칭될 표현들을 포함할 수도 있다(그리고 문장들은 매칭 노드들에서 평가될 수 있다). 여기의 일례에서는 XSLT 스타일 시트들이 사용될 수도 있지만, 일반적으로 "스타일 시트"는 소스 문서를 출력 문서로 변환하기 위한 임의 스펙을 구비할 수 있다. 소스 및 출력 문서들은 동일한 언어일 수 있거나(예를 들어, 소스 및 출력 문서들은 상이한 XML 어휘들일 수 있거나), 상이할 수도 있다(예를 들어, pdf에 대한 XML 등). 스타일 시트들의 다른 예는 HTML 및/또는 XML 쿼리를 위해 정의된 캐스케이딩 스타일 시트들(cascading stylesheets)일 수도 있다.

스타일 시트에 사용되는 표현들은 일반적으로, 노드 식별자들 및/또는 값들 사이의 부모/자식(parent/child)(또는 선조/후손(ancestor/descendant)) 관계들을 특정하기 위한 노드 식별자들에 대한 연산자들과 함께, 노드 식별자들 및/또는 노드들의 값들을 구비한다. 노드 식별자는 명칭(예를 들어, 구성 요소 명칭, 속성 명칭 등)을 구비할 수 있거나, 유형에 의해 노드를 식별하는 표현 구성체(expression construct)를 구비할 수도 있다(예를 들어, 노드 테스트 표현은 임의의 노드와 매칭될 수 있고, 또는 텍스트 테스트 표현은 임의의 텍스트 노드와 매칭될 수 있다). 일부 경우들에서, 명칭은 특정 명칭 공간에 속할 수 있다. 이런 경우들에서, 노드 식별자는 명칭 공간과 연관되어 있는 명칭일 수 있다. XML에서, 명칭 공간은 구성 요소 및 속성 명칭들을 URI(universal resource identifier)에 의해 식별되는 명칭 공간 명칭들과 연관짓는 것에 의해 구성 요소 및 속성 명칭들에 권한을 부여하는 방법을 제공한다. 따라서, 노드 식별자는 권한이 부여된 명칭(명칭에 있달아 콜론이 수반되는 선택적인 명칭 공간 프리픽스(optional namespace prefix))일 수 있다. 여기에서 사용되는 명칭(예를 들어, 구성 요소 명칭, 속성 명칭 등)은 권한이 부여된 명칭(qualified name)을 포함할 수 있다. 또한, 표현들은 노드를 매칭하기 위한 추가 조건(들)일 수 있는 술어들(predicates)도 포함할 수 있다. 술어는, 연관된 노드에 의해 (다음에서 정의되는) 문맥 노드로서 평가되는 표현인데, 이 경우, 표현의 결과는 참(및 노드는 표현 노드와 매칭될 수 있음)이거나 거짓(및 노드는 표현과 매칭되지 않음)이다. 따라서, 표현을, 문서 트리에 대하여 매칭되어야 할 노드들의 트리로서 볼 수도 있다. XSLT에서 사용되는 표현 언어인 XPath에서, 표현은 "문맥 노드(context node)"의 문맥으로도 평가될 수 있다(즉, 표현들은, 표현의 노드 식별자들을 문맥 노드의 선조들, 후손들, 부모들, 또는 자식들로서 뿐만 아니라 다른 노드 식별자들에 대한 관계들로서 특정하는, 문맥 노드에 관한 것일 수도 있다). 소정의 문서 노드가 표현의 평가를 통해 선택된다면, 소정의 문서 노드는 표현을 충족시킬 수 있다. 즉, 표현의 표현 노드 식별자들은 표현에서 특정된 소정의 문서 노드에 대해 동일한 관계를 가진 소정의 문서 노드 명칭 또는 문서 노드 명칭들과 매칭되고, 표현에서 사용되는 값들은 소정의 문서 노드에 관련된 대응 값들과 동일하다. 또한, 노드가 소정 표현을 충족시키면, 문서 노드를 소정 표현에 대한 "매칭 노드"라고 할 수도 있다. 본 논의에 대한 나머지의 일부 경우들에서는, 표현 트리들의 노드들을 문서의 노드들과 구분하는 것이 명료화에 도움이 될 수도 있다. 따라서, 노드가 표현 트리의 일부라면 그 노드는 "표현 노드"라고 할 수 있고, 노드가 프로세싱되고 있는 문서의 일부라면 그 노드는 "문서 노드"라고 할 수 있다.

도시된 실시예에서, 문서들에 스타일 시트들을 적용하는 것은 다음의 방식으로 수행될 수 있다: 스타일 시트 컴파일러(20)는 프로세서들(14A-14B) 중 하나에서 스타일 시트를 문서 프로세서(16)에 의한 사용을 위한 하나 이상의 데이터 구조들 및 코드로 컴파일링하도록 실행되는 소프트웨어(즉, 복수개의 명령어들)를 구비할 수 있다. 문서 프로세서(16)는 데이터 구조들을 소스 문서에 적용하여 출력 문서를 발생시킬 수 있다.

특히, 일 실시예에서, 스타일 시트 컴파일러(20)는, 문서 프로세서에 의해, (문자 스트링 비교들을 수반할) 노드 식별자들이 아니라, 번호들을 비교하는 것에 의해 표현 평가가 수행될 수 있도록, 노드 식별자들에 일련 번호들을 할당할 수도 있다. 스타일 시트 컴파일러(20)는 노드 식별자들의 일련 번호들로의 매핑을 심볼 테이블들(24)에 저장할 수도 있다. 또한, 스타일 시트 컴파일러(20)는 스타일 시트로부터 표현들을 추출하여, 표현 매칭을 위해 문서 프로세서에 의해 사용될 표현 트리 데이터 구조들(예를 들어, 파싱-시간 표현 트리(26))을 발생시킬 수도 있다. 또한, 스타일 시트 컴파일러(20)는 각각의 매칭 표현을 위해 실행될 명령어들(및, 일 실시예에서는, 실행-시간 술어들을 평가하도록 실행될 명령어들)을 갖춘 명령어 테이블(30)을 발생시킬 수도 있다. 명령어 테이블의 명령어들은, 문서 프로세서(16)에 의해 실행될 경우, 표현이 매칭될 경우 실행될 것으로 정의된 액션들이 수행되는 결과를 초래할 수 있다. 일부 실시예들에서는, 명령어들이 수행될 액션들을 구비할 수 있다(즉, 명령어들과 액션들 사이에 일 대 일 대응 관계가 존재할 수 있다). 다른 실시예들에서, 적어도 일부 액션들은 2 이상의 명령어들을 실행하는 것에 의해 실현될 수도 있다. 스타일 시트 컴파일러(20)는, 소스 문서의 다양한 여백 유형들이 취급되는 (예를 들어, 보존되거나, 분리되는 등의) 방법을 정의하는 여백 테이블들(32), 표현 리스트 테이블(36) 및 템플릿 리스트 테이블(38)을 발생시킬 수도 있다.

스키마 컴파일러(22)도 마찬가지로 프로세서들(14A-14B) 중 하나에서 실행되는 명령어들을 구비할 수 있다. 스키마 컴파일러(22)는 스키마 또는 DTD를 컴파일링하여 (노드 식별자들을 일련 번호들로 대체하는) 하나 이상의 심볼 테이블들(24) 뿐만 아니라 DTD 테이블들(34)을 발생시킨다. 일반적으로, DTD 또는 스키마는 허용 가능한 문서 구조 및 요구되는 문서 구조 모두의 식별 정보를 구비할 수도 있다. 따라서, 문서의 저자는, DTD 및/또는 스키마로써, 유효 문서의 요구되는 그리고 허용되는 구조를 설명할 수 있다. 일부 경우들에서, DTD 또는 스키마는 속성들을 위한 디폴트 값들도 포함할 수 있다. 일 실시예에서, DTD/스키마는 다양한 정보: 문서의 엔티티 참조들, 유효 문서를 위해 요구되는 속성들인 소정 구성 요소의 속성들, 문서의 소정 구성 요소에서 특정되지 않을 수도 있는 속성들을 위한 속성 디폴트 값들, 문서 구조를 위한 요구 사항들(예를 들어, 소정 하부 구성 요소의 요구되는 최소/최대/특정 갯수 등), 및 문서의 허용 가능 구조에 대한 정의를 포함할 수 있다. DTD 테이블들(34)은 엔티티 참조 대체들(entity reference replacements)의 테이블, 요구되는 속성들의 테이블, 속성 디폴트들의 테이블, 및 허용 가능 구조(및, 적용 가능하다면, 요구되는 구조)를 식별하는 골격 트리(skeleton tree)를 포함할 수도 있다.

문서 프로세서(16)는 문서를 파싱하고 문서 노드들을 파싱-시간 표현 트리의 표현 노드들에 매칭하기 위한 하드웨어 회로를 구비할 수 있다. 다시 말해, 문서를 파싱하고 문서 노드들을 표현 노드들에 매칭하는 하드웨어 회로는, 어떤 소프트웨어 명령어들도 실행하지 않으면서, 이러한 연산들을 수행할 수 있다. 하드웨어는 매칭 문서 노드들의, 각 표현에 대해, 파싱된 컨텐츠 및 지시들을 저장하는 다양한 데이터 구조들을 발생시킬 수 있다. 그 다음, 하드웨어는 그러한 소정 표현의 각각의 매칭 문서 노드에 대해 소정 표현을 위한 명령어 테이블(30)로부터의 명령어들을 실행시켜, 출력 문서를 산출하기 위해 조합되는 결과들을 발생시킬 수 있다. 다음에서는, 일 실시예의 추가적인 세부 사항들이 제공된다.

상술된 바와 같이, 도시된 실시예에서, 스타일 시트 컴파일러(20) 및 스키마 컴파일러(22)는 소프트웨어로 구현되고, 문서 프로세서(16)는 하드웨어로 구현된다. 일부 실시예들에서는, 컨텐츠 변환 어플라이언스(10)에 대한 성능에서의 중요한 팩터는, 변환 요청이 형성되고 문서가 제공될 때의 문서 프로세싱일 수 있다. 다시 말해, 스타일 시트들 및/또는 스키마들은, 많은 경우들에서, 프로세싱되고 있는 문서들의 수에 비해 비교적 덜 빈번하게 변한다. 스타일 시트들이 (업데이트된 스타일 시트로 또는 완전히 상이한 스타일 시트로) 변경되기 전에, 소정의 스타일 시트가 다수 문서들(예를 들어, 대략 몇 십개 이상의 문서들)에 적용될 수 있다. 스키마 및 이들이 적용될 문서들에 대해서도 유사한 관계가 성립될 수 있다. 따라서, (소프트웨어를 사용해) 스타일 시트들/스키마로부터의 비교적 불변의 정보를 전용의 맞춤형 하드웨어에 의해 효율적으로 액세스될 수 있는 데이터 구조들로 포착해 내는 것이 고성능 솔루션을 제공할 수 있다. 또한, 스타일 시트/스키마 컴파일레이션을 하드웨어로 구현하는 것이, 일부 실시예들에서는, 상이한 스타일 시트/스키마 언어들을 구현하기 위한 그리고/또는, 맞춤형 하드웨어를 변경할 필요없이, 언어 스펙들에서의 변화들을 구현하기 위한 융통성을 제공할 수 있다. 예를 들어, XSLT, XPath, 및 XML 스키마는 여전히 발전하는 중일 수 있으며, 미래에 새로운 사양들이 이들 언어들에 추가될 수도 있다. 컴파일러들은 이러한 새로운 사양들을 핸들링하도록 적응될 수 있다. 사용될 스타일 시트/스키마가 미리 제공됨으로써, 스타일 시트/스키마를 컴파일링하기 위한 시간이 덜 중요할 수도 있다. 그러나, 다른 실시예들에서는, 스타일 시트 컴파일러(20) 및 스키마 컴파일러(22) 중 하나 또는 모두가 하드웨어로 또는 하드웨어와 소프트웨어의 조합으로 구현될 수도 있다.

네트워크 인터페이스 회로(12)는 네트워크 커넥션들에 대한 낮은 레벨의 전기 및 프로토콜 세부 사항들을 핸들링할 수 있고, 수신된 패킷들을 프로세싱을 위해 프로세서들(14A-14B)로 전달할 수도 있다. 네트워크의 임의 유형이 사용될 수도 있다. 예를 들어, 일부 실시예들에서, 네트워크 커넥션들은 기가바이트 이더넷 접속들일 수 있다. 필요하다면, 소정 레벨의 대역폭을 실현하기 위해 그리고/또는 네트워크 커넥션들에 리던던시를 제공하기 위해 하나 이상의 커넥션이 제공될 수도 있다.

프로세서들(14A-14B)은 임의 유형의 프로세서를 구비할 수도 있다. 예를 들어, 일 실시예에서, 프로세서들(14A-14B)은 PowerPC 네트워크 프로세서들일 수 있다. 다른 실시예들에서, 프로세서들(14A-14B)은 ARM, Intel의 IA-32, MIPS 등과 같은 다른 명령어 세트의 아키텍처를 구현할 수도 있다.

프로세서들(14A-14B), 문서 프로세서(16), 및 메모리(18)를 결합하기 위해 임의의 인터커넥트가 사용될 수도 있다. 또한, 프로세서들(14A-14B)은 프로세서들(14A-14B) 및 문서 프로세서(16)로부터 메모리(18)까지의 커넥션과는 별도로 문서 프로세서(16)에 결합될 수도 있다. 예를 들어, 일 구현에서는, 프로세서들(14A-14B)이 하나 이상의 PCI-X(peripheral component interconnect express) 버스들을 사용해 문서 프로세서(16)에 결합될 수도 있다.

일부 경우들에서는, DTD, 스키마, 또는 스타일 시트가 (직접적으로 또는 스키마나 스타일 시트로의 포인터로서) 문서에 매입될 수도 있다는 것에 주의해야 한다. 이런 경우들에서, DTD, 스키마, 또는 스타일 시트는 문서로부터 추출되어, 개별적으로 제공되는 스키마 또는 스타일 시트에 대해 설명된 바와 같이 프로세싱될 수 있다.

메모리(18)는 임의 유형의 휘발성 또는 비-휘발성 메모리를 구비할 수 있다. 예를 들어, 메모리(18)는 RAM(예를 들어, SDRAM, RDRAM, SRAM 등), 플래시 메모리 또는 배터리-백업형 RAM과 같은 비-휘발성 메모리, 디스크 또는 CD-ROM과 같은 자기 또는 광 스토리지 등 중 하나 이상을 포함할 수 있다. 메모리(18)는, 개별적으 로 액세스 가능한 다수 메모리들(예를 들어, 프로세서들(14A-14B)에 대해서만 액세스 가능한 파티션 또는 파티션들 및 문서 프로세서(16)에 대해서만 액세스 가능한 다른 파티션 또는 파티션들)을 구비할 수도 있다.

도 1은 메모리(18)에 저장되어 있는 스타일 시트 컴파일러(20) 및 스키마 컴파일러(22)를 도시한다. 일반적으로, 스타일 시트 컴파일러(20) 및/또는 스키마 컴파일러(22)는 임의의 컴퓨터 액세스 가능 매체상에 인코딩될 수 있다. 일반적으로 말하면, 컴퓨터 액세스 가능 매체는 사용하는 동안 컴퓨터에 의해 명령어들 및/또는 데이터를 컴퓨터에 제공하도록 액세스될 수 있는 임의의 매체들을 포함할 수 있다. 예를 들어, 컴퓨터 액세스 가능 매체는 자기 또는 광 매체들, 예를 들어, (고정형 또는 분리형) 디스크, CD-ROM, 또는 DVD-ROM과 같은 저장 매체들, RAM(예를 들어, SDRAM, RDRAM, SRAM 등), ROM, 플래시 메모리 등과 같은 휘발성 또는 비-휘발성 메모리 매체들 뿐만 아니라 네트워크 및/또는 무선 링크와 같은 통신 매체를 통해 전달되는, 전기, 전자기, 또는 디지털 신호들과 같은 전송 매체들 또는 신호들을 통해 액세스 가능한 매체들도 포함할 수 있다.

일부 실시예들에서, 컴퓨터 액세스 가능 매체는 컴파일레이션을 수행하기 위해 스타일 시트 컴파일러(20) 및/또는 스키마 컴파일러(22)를 실행할 수 있는 별도의 컴퓨터 시스템 또는 시스템들에 포함될 수도 있다. 컴파일레이션으로부터 얻어지는 데이터 구조들/코드는 (예를 들어, 컨텐츠 변환 어플라이언스(10)로의 네트워크 커넥션을 통해) 컨텐츠 변환 어플라이언스(10)로 전달될 수도 있다.

여기에서의 설명은 스타일 시트가 문서에 적용되는 일례들을 포함할 수 있지 만, 다른 일례들은 다수의 스타일 시트들을 (필요에 따라, 동시에 또는 직렬로) 문서에 적용하는 단계 및 스타일 시트를 (필요에 따라, 문맥 전환과 동시에 또는 직렬로) 다수 문서들에 적용하는 단계를 포함할 수도 있다는 것에 주의한다.

다음으로 도 2를 참조하면, 문서 프로세서(16)의 일 실시예의 블록도가 도시되어 있다. 도 2의 실시예에서, 문서 프로세서(16)는 파서 회로(40), 표현 프로세서(42), 변환 엔진(44), 출력 발생기(46), 및 평가기 회로(48)를 포함한다. 파서 회로(40)는 표현 프로세서(42) 및 출력 발생기(46)에 결합되어 있다. 표현 프로세서(42)는, 출력 발생기(46)에 결합되어 있는 변환 엔진(44)에 결합되어 있다. 평가기(48)는 출력 발생기(46)에 결합되어 있다. 도 2의 유닛들은 (예를 들어, 유닛들간의 신호 라인들을 사용해) 서로 직접적으로 결합될 수 있거나, 메모리(18)를 통해 결합될 수 있거나(예를 들어, 소스 유닛은 수신지 유닛으로 전달될 정보를 메모리(18)에 기입할 수 있고, 수신지 유닛은 메모리(18)로부터 정보를 판독할 수 있다), 이 모두일 수도 있다.

파서 회로(40)는 문서를 수신하여 문서를 파싱함으로써, 표현 프로세서(42) 및 평가기 회로(48)를 위한 이벤트들을 식별할 수 있고 파싱된 컨텐츠를 가진 데이터 구조들을 발생시킬 수도 있다. 문서 프로세서(16)가 스타일 시트에 따라 문서를 변환해야 한다면, 파싱된 컨텐츠는 변환 엔진(44)을 위한 메모리(18)에 데이터 구조들로 저장될 수도 있다. 다른 방법으로, 문서가 파싱되기만 해야 한다면, 파서 회로(40)는 SAX 또는 DOM 포맷으로 출력될 파싱된 컨텐츠를 출력 발생기(46)에 제공할 수도 있다. 파서 회로(40)는 파싱된 컨텐츠를 메모리(18)를 통해서도 출력 발생기(46)에 제공할 수 있다.

표현 프로세서(42)는 (문서로부터 파싱된 문서 노드들을 식별하는) 파서 회로(40)로부터 이벤트들을 수신하고, 파서 회로(40)에 의해 식별된 문서 노드들을 파싱-시간 표현 트리에 대하여 비교한다. 표현 프로세서(42)는 각 표현에 대한 매칭 문서 노드들의 리스트들을 변환 엔진(44)으로 출력한다. 변환 엔진(44)은 파서 회로(40)에 의해 구축된 파싱된 컨텐츠의 데이터 구조들 및 매칭 문서 노드들의 리스트들을 수신하고, 명령어 테이블(30)로부터의 대응되는 명령어들을 실행하여 출력 문서를 위한 결과들을 발생시킨다. 일부 실시예들에서, 각각의 명령어는 다른 명령어들에 의존하지 않으므로, 실행은 어떤 순서로도 발생할 수 있다. 출력 발생기(46)는 결과들을 순서대로 재조립할 수도 있고 출력 문서를 메모리(18)에 기입할 수도 있다(또는 출력 문서를 메모리(18)를 통해 전달하지 않으면서 프로세서들(14A-14B)로 송신할 수도 있다). 프로세서들(14A-14B)은, 출력 문서를 판독하여 요청자에게 출력 문서를 전송하기 위해, 소프트웨어를 실행할 수도 있다.

평가기 회로(48) 또한 파서 회로(40)에 의해 송신되는 이벤트들을 수신할 수 있고, (골격 트리 및 DTD 테이블들(34)에 의해 표현되는) 스키마/DTD를 적용할 수 있으며, 스키마에서 지시되는 바에 따라 문서가 유효한지를 판정할 수도 있다. 문서가 유효하다면, 평가기 회로(48)는 출력 발생기(46)로 전송될 성공 메시지를 발생시킬 수도 있다. 문서가 유효하지 않다면, 평가기 회로(48)는 (실패의 이유(들)를 지시하는) 실패 메시지를 발생시킬 수 있으며 실패 메시지를 출력 발생기(46)로 전송할 수도 있다. 출력 발생기(46)는 메시지를 메모리(18)에 저장할 수도 있다 (그리고 프로세서들(14A-14B)은 메시지를 요청자에게 후속적으로 전송할 수도 있다).

이제 도 3을 참조하면, 문서 프로세서(16)의 일부(특히, 파서 회로(40), 표현 프로세서(42), 및 변환 엔진(44)) 및 프로세서(14A)가 도시되어 있다. 도 3은 컨텐츠 변환 어플라이언스(10)의 일 실시예에 따른 도시된 부분들간의 통신을 좀더 상세하게 강조한다. 프로세서(14B) 또한 프로세서(14A)를 위해 설명된 방식으로 동작할 수도 있다.

프로세서(14A)는, 컨텐츠 변환 어플라이언스(10)가 결합되어 있는 네트워크(들)로부터 패킷들을 수신할 수 있다. 패킷들의 데이터 페이로드는 컨텐츠 변환 어플라이언스(10)에 의해 변환될 문서를 구비할 수 있다. 또한, 수신된 다른 패킷들은 다른 통지들(예를 들어, 스타일 시트나 스키마, 또는 컨텐츠 변환 어플라이언스(10)와의 다른 통지들)도 포함할 수 있다. 프로세서(14A)는 문서를 재조립할 수 있고 재조립된 문서를 파서 회로(40)로 전달할 수도 있다.

파서 회로(40)는 재조립된 문서를 프로세서(14A)로부터 수신하고, 메모리(18)로부터의 심볼 테이블들(24), DTD 테이블들(34), 및 여백 테이블들(32)에도 액세스한다. 파서 회로(40)는 문서를 파싱하여, 검출된 문서 노드들에 관련된 이벤트들을 발생시킨다. 좀더 구체적으로, 파서 회로(40)는 문서의 노드 식별자들을 심볼 테이블들(24)의 대응되는 일련 번호들로 변환하고, 일련 번호들을 이벤트들의 일부로서 표현 프로세서(42)로 전송한다. 또한, 파서 회로(40)는 문서의 파싱된 컨텐츠를 변환 엔진(44)을 위해 저장하는 파싱된 컨텐츠 테이블들을 발생시킨다. 표현 프로세서(42)는 파서(40)로부터 이벤트들을 수신하고, 식별된 문서 노드들을 (그들의 일련 번호들에 기초해) 파싱-시간 표현 트리(26)에 대하여 비교한다. 매칭 문서 노드들은 식별되어, 변환 엔진(44)으로 송신될 템플릿 및 표현 매치 리스트들에 기록된다.

변환 엔진(44)은 템플릿 및 표현 매치 리스트들과 파싱된 컨텐츠 테이블들을 수신하고, 명령어 테이블(30)도 수신한다. 변환 엔진(44)은 임의의 실행-시간 표현들을 평가하고, 템플릿 및 표현 매치 리스트들로부터 실행-시간 표현들을 충족시키지 않는 노드들을 삭제한다. 또한, 변환 엔진(44)은 그 표현과 매칭되는 문서 노드들 각각에서 각 표현을 위한 명령어 테이블(30)로부터의 명령어들을 실행하고, 결과들을 출력 발생기(46)로 출력한다.

도시된 실시예에서, 프로세서(14A)는 재조립된 문서를 인라인(inline)으로 전송할 수 있고, 파서 회로 또한 마찬가지로 이벤트들을 표현 프로세서(42)로 인라인으로 전송할 수 있다. 다시 말해, 문서의 일부분들이 프로세서(14a)에 의해 수신되고 재조립됨에 따라, 프로세서(14A)는 문서의 그 부분을 파서 회로(40)로 전달한다. 이와 같이, 파서 회로(40)는, 프로세서(14A)가 문서 전체를 수신하기 전에 파싱을 시작할 수 있다. 마찬가지로, 이벤트들은, 그들이 식별됨에 따라, 표현 프로세서(42)로 전달된다. 한편, 파싱된 컨텐츠 테이블들 및 템플릿/표현 매치 리스트들은 (변환 엔진(44)으로의 통지들상의 점선형 타원에 의해 지시되는 바와 같이) 메모리(18)를 통해 전달된다. 여기에서 사용되는 바와 같이, (소스 또는 수신기가 전달을 위해 일시적으로 데이터를 큐잉할 수도 있기는 하지만) 데이터가 메모 리(18)와 같은 메모리에 버퍼링되지 않고 직접적으로 전달된다면, 데이터는 소스로부터 수신기로 "인라인"으로 전송된다. 인라인으로 전송되는 데이터는 메모리를 통한 전송보다 지연을 덜 겪을 수도 있다.

이제 도 4를 참조하면, 문서들을 변환하기 위한 방법의 일 실시예를 예시하는 흐름도가 도시되어 있다. 일반적으로, 본 방법은, 문서 변환이 복수개의 단계들을 포함하는 경우에 적용될 수 있다. 스타일 시트의 표현들은, 그들이 평가될 수 있는 최초 단계에 따라 분류될 수 있다. 그 다음, 각각의 단계 동안, 그 단계에서 평가될 수 있는 표현들이 평가된다. 이와 같이, 각각의 표현이 최초의 가능한 단계에서 평가될 수 있으므로, 차후 단계들에서 평가될 표현들은 좀더 적어지게 된다.

도시된 실시예에서, 단계들은 컴파일 시기(phase), 파싱 시기, 및 변환 시기를 포함할 수 있다. 컴파일 시기에서는, 스타일 시트의 표현들이 (예를 들어, 이 문서에서의 컴파일링-시간, 파싱-시간, 또는 실행-시간으로서) 특징지워진다(블록 50). 또한, 컴파일 시기에서는, 컴파일링-시간 표현들이 평가된다(블록 52). 파싱 시기 동안에는, 파싱-시간 표현들이 평가된다(블록 54). 변환 시기 동안에는, 실행-시간 표현들이 평가된다(블록 56).

일부 실시예들에서는, 실행-시간 표현들이, 먼저 평가 가능한 부분들(예를 들어, 파싱-시간) 및 실행-시간인 부분들로 분리될 수도 있다. 먼저 평가 가능한 부분들이 실행-시간 부분들에 따라 평가되고 분류될 수도 있다. 다시 말해, 표현의 파싱-시간 부분과 매칭되며 표현의 실행-시간 부분을 위해 사용되는 동일 값 (들)을 가진 문서 노드들은 그룹화된다. 실행-시간에서는, 표현의 실행-시간 부분이 평가되고, 그룹에 대응되는 값이 표현의 실행-시간 부분을 충족시키지 않으면, 그 그룹은 삭제된다. 표현의 실행-시간 부분을 충족시키는 그룹들만이 유지되고, 유지된 그룹들의 문서 노드들에 대해 명령어들이 실행된다.

XSLT 스타일 시트들을 구현하는 일 실시예에서, 표현이 선조/자손 참조들(//) 및 술어들을 포함하지 않으면, 표현은 컴파일링-시간일 수도 있다. 표현이 현재 노드, 후속의 형제 노드, 또는 구성 요소 값을 참조하는 술어들을 포함하지 않으면, 표현은 파싱-시간일 수도 있다. 컴파일링-시간 또는 파싱-시간이 아닌 표현들은 실행-시간 표현들(예를 들어, 현재 노드를 참조하거나 후속의 형제 노드 또는 구성 요소 값을 참조하는 술어들을 포함하는 표현들)이다. 현재 노드를 참조하지 않는 실행-시간 표현들의 경우, 앞서 언급된 술어들을 포함하지 않는 부분들은 파싱-시간시에 평가될 수도 있다. 이러한 문맥에서, 현재 노드는, 표현이 템플릿 매칭 표현이라면, 문맥 노드일 수 있거나, 템플릿 바디내의 문장들(예를 들어, 템플릿 바디내의 루프 구성체들 또는 다른 표현들)에서 참조되는 노드들일 수 있다.

어떤 표현들이 파싱-시간 대 실행-시간인지는, 부분적으로, 표현 프로세서(42)의 인라인 특징에 의해 영향을 받을 수도 있다. 다시 말해, 문서 노드들은 식별되어 인라인으로 표현 프로세서(42)로 전달된다. 대조적으로, 표현 프로세싱이 인라인이 아니라면, 과거 및 미래의 문서 노드들은, 특정 노드를 프로세싱하는 중에 위치가 지정될 수도 있다. 따라서, 표현 프로세싱이 인라인이 아니라면, 현재 노드를 참조하는 표현들만이 핸들링되지 않을 수도 있다. 인라인 프로세싱의 경우, 표현 트리들에 대하여 문서 노드들을 매칭하는 단계는 일반적으로, 표현 트리의 어떤 표현 노드들이 선행 문서 노드들과 매칭되었는지에 관한 정보를 보유하는 단계를 포함할 수도 있다. 그 다음, 선행 문서 노드의 자식 또는 후손이 파서 회로(40)에 의해 식별되면, 그러한 자식/후손 노드들은, 표현 트리의 선행 매칭된 표현 노드들에 링크되어 있는 표현 트리의 후속 레벨들과 비교될 수도 있다.

컴파일링-시간 표현을 평가하는 단계는 "선택된 것을 템플릿들에 적용하기(apply templates select)" 문장의 표현들에 적용될 수도 있다. 앞서 언급된 바와 같이, "템플릿들 적용하기(apply templates)" 문장은 템플릿 바디의 문맥에서 한 세트의 노드들을 선택하고, 템플릿들을 노드들에 적용한다. "선택된 것을 템플릿들에 적용하기" 문장은, 한 세트의 노드들을 선택하는 표현을 포함한다. 그 다음, 한 세트의 노드들은 스타일 시트의 템플릿들에 적용된다. "선택된 것을 템플릿들에 적용하기" 문장의 표현이 앞서 주어진 컴파일링-시간 정의를 충족시키면, 컴파일러는, (존재한다면) 세트의 노드들이 매칭될 수 있는 템플릿들을 판정할 수도 있다. 이와 같이, 이런 경우들에서는 템플릿을 매칭하는 단계가 생략될 수도 있다. 일 실시예에서, 컴파일러는 선택된 것을 템플릿들에 적용하기 문장의 표현들과 템플릿 매칭 조건들을 구비하고 있는 표현들 사이에서 대수 결합(algebraic match up)을 수행할 수도 있다. 파싱-시간 및 실행-시간 표현들을 비교하는 단계는, 표현들을 충족시키는 노드들을 판정하는 단계를 구비할 수도 있다.

일 실시예에서, XML 스키마에 의해 설명되는 XML 문서들의 문맥에서 XPath 표현들의 대수 매칭은 다음에서 설명되는 바와 같이 수행될 수도 있다. 다음의 정 의들은 XPath 표현들 및 XML 스키마를 위한 대수 매칭 알고리즘을 설명하는데 유용할 수 있다. P가 XPath 표현이고 S가 XML 스키마라면, P에서 발생하는 각각의 구성 요소 및 속성 명칭이 S에서 선언되고 S에서 동일한 유형(구성 요소 또는 속성)을 가질 경우에만, P가 S를 위해 정의될 수 있다. P 및 Q가 2개의 XPath 표현들이라면, P를 충족시키는, S에 기초한 임의 입력 문서(D)의 각 노드가 Q도 충족시킬 경우에만, P는 S를 위한 매칭(Q)으로서 참조될 수 있다. "단순한" 표현은, "//" 연산자 및 "." 연산자를 포함하는 표현일 수 있다. 이러한 정의들이 주어지면, 일 실시예의 대수 매칭은 표현(P) 및 하나 이상의 단순한 표현들의 세트(E)에 대해 다음과 같이 수행될 수도 있다. 먼저, 표현들이 표준화될 수도 있다. "/"로써 시작하는 표현은 표준 형태이다. 표현(Q)이 "/"로 시작하지 않으면, 그것은 다음과 같이: (i) Q가 임의 루프들의 범위내에 존재한다면, (각각의 선택 표현 및 Q를 / 연산자에 의해 분리하면서) 각각의 루프를 위한 선택 표현들로써 Q를 프리펜딩(prepending)함으로써, 가장 안쪽의 루프 선택 표현이 Q에 가장 가까워지게 하고, 프리펜딩된 표현의 시작으로서 가장 바깥쪽의 루프 선택 표현으로 진행하게 하며; (ii) Q가 발생하는 템플릿의 템플릿 매칭 조건으로써 (i)로부터 형성된 표현을 프리펜딩하고; (iii) 템플릿 매칭 조건이 "/"이 아니라면, (i) 및 (ii)로부터 형성된 표현을 "//"로써 프리펜딩하는 것과 같이, 표준화된다. (상술된 바와 같이 표준화된) 단순한 표현들(E)이 형성될 수 있다면, 술어들이 무시된다는 것을 제외하면, 파싱-시간 표현 트리(26)와 유사한 표현 트리가 형성될 수도 있다. 이와 같이, (술어들의 제외가 가능한) 동일한 표현들이 표현 트리의 동일한 경로로 매핑될 수 있고 표현 트리의 동일한 리프 노드(leaf node)와 연관지워진다. P가 표현 트리에 대하여 매칭된다(다시 말해, P에서의 각각의 노드 식별자 또는 연산자가 동일한 위치의 표현 트리와 매칭된다면, 매칭이 발생한다). P가 소진되는 동일 시점에 표현 노드의 리프 노드에 도달된다면, 그러한 리프 노드와 연관된 표현들은 P와 매칭되는 E의 표현들이다. 이러한 매칭 표현들은, 생략될 수 있는 컴파일링-시간 표현들일 수도 있다.

이제 도 5를 참조하면, 스타일 시트 컴파일러(20)의 일 실시예를 예시하는 흐름도가 도시되어 있다. 스타일 시트 컴파일러(20)가 소프트웨어로 구현되는 실시예들에서, 스타일 시트 컴파일러(20)는, 실행시 도 5에 도시된 펑크션들을 구현하는 명령어들을 구비한다. 도 5의 블록들이 스타일 시트 컴파일러(20)의 펑크션을 예시하기는 하지만, 본 흐름도가, 컴파일러가 펑크션들을 열거된 순서대로 수행한다거나 후속 펑크션을 시작하기 전에 일 펑크션이 스타일 시트에 대해 전체적으로 완전히 실행된다는 것을 함축하는 것은 아니라는 것에 주의해야 한다.

스타일 시트 컴파일러(20)는 스타일 시트의 표현들을 식별하고(블록 60), 표현들을 컴파일링-시간, 파싱-시간, 또는 실행-시간으로서 분류한다. 표현들은 템플릿 매칭하기 문장들, 템플릿들 적용하기 문장들, 및 스타일 시트의 다양한 다른 문장들에 존재할 수 있다. 스타일 시트 컴파일러(20)는 각 표현의 정규 형태를 발생시킨다(블록 62). 일반적으로, 상이한 방법들이 논리적으로 등가이기는 하지만, 소정 표현을 표현하기 위한 다수의 상이한 방법들이 존재할 수도 있다. 정규 형태는, 등가 표현들(또는 등가인 표현들 중 일부들)을 식별하는 프로세스를 간략화하 도록, 소정 표현을 표현하기 위한 소정 방법을 특정한다. 스타일 시트 컴파일러(20)는 표현들의 노드 식별자들에 일련 번호들을 할당한다(블록 64).

스타일 시트 컴파일러(20)는 표현들에 공통의 프리픽스 압축을 수행하여 파싱-시간 표현 트리를 구축할 수도 있다(블록 66). 앞서 언급된 바와 같이, 표현들은 일반적으로, 문서의 노드 식별자들에 매칭될 노드 식별자들의 계층 구조 리스트를 포함할 수 있다. 이와 같이, 다양한 표현들은 공통 부분들(특히, 다양한 표현들을 위해 동일할 수 있는, (루트에 좀더 근접한) 계층 구조에서 좀더 상위의 표현 노드들)을 가질 수도 있다. 따라서, 공통인 부분들은 표현들의 제 1 부분(표현들의 "프리픽스")에 존재할 수 있다. 이러한 표현들을 파싱-시간 표현 트리에서 다같이 압축하는 것에 의해, 공통 부분은 파싱-시간 표현 트리에 한번만 표현될 수 있고, 일단 표현들이 달라지기 시작하면, 표현들의 나머지는 공통 부분의 자식들이 된다. 따라서, 문서 노드와 매칭될 수 있는 다수 표현들이 파싱-시간 표현 트리의 공통 부분에서 병렬로 평가될 수 있고, 차이점들이 발생할 때는 트리에서 분기할 수도 있다. 이런 경우들에서, 파싱-시간 표현 트리는 좀더 컴팩트할 수 있고, 좀더 빠르게 프로세싱될 수 있다.

예를 들어, (일련 번호들이 할당된 후의) 2개 표현들은 /10/15/20/25 및 /10/15/20/30/35일 수 있다. 이들 2개 표현들은 /10/15/20/을 공통으로 가진다. 따라서, 이들 2개 표현들은 파싱-시간 표현 트리에서 노드 15를 자식으로 가진 노드 10 및 노드 20을 자식으로 가진 노드 15를 구비하는 공통 부분으로서 표현될 수 있다. 노드 20은 2개 자식들(25 and 30)을 가질 수 있다. 노드 30은 노드 35를 자식으로 가질 수 있다. 문서 노드들이 파싱되어 표현 프로세서(42)로 전달됨에 따라, 표현들은, 노드 20에 도달될 때까지, 문서 노드들에 대하여 병렬로 평가될 수 있다. 그 다음, 후속의 자식 문서 노드는 표현 노드들 25 또는 30 중 0개 또는 1개에 대하여 매칭될 수 있다.

앞서 언급된 바와 같이, 스타일 시트 컴파일러(20)는 실행-시간 표현들을 파싱-시간에서 평가될 수 있는 부분들 및 실행-시간에서 평가될 수 있는 부분들로 나눌 수 있다. 파싱-시간 부분들은 파싱-시간 표현 트리에 포함될 수 있다. 실행-시간 술어가 발생하는 파싱-시간 표현 트리의 각 레벨에서, 스타일 시트 컴파일러(20)는, 술어가 실행-시간에서 평가되고, 매칭 문서 노드들이 실행-시간 술어를 충족시키는지의 여부에 따라, 매칭 문서 노드들이 보유되거나 파기될 수 있도록, 매칭 노드들이 그룹화될 것을 지시할 수 있다(그리고 실행-시간 술어에 의해 사용되는 정보는 보유될 수 있다). 소정의 실행-시간 표현은 표현의 다양한 레벨들에서 하나 이상의 실행-시간 술어를 포함할 수 있으므로, 다수 레벨들의 그룹화가 발생할 수도 있다. 각각의 그룹화 레벨에서, 실행-시간 술어에 대응되는 동일 값을 가진 문서 노드들은 함께 그룹화된다. 실행-시간 술어가 평가될 때, 그 값이 실행-시간 술어와 매칭되지 않으면, 문서 노드들의 그 그룹(및 그 그룹의 임의의 하부 그룹들)은 파기된다. 값이 평가되는 실행-시간 술어와 매칭되는 그룹들은 보유되고 변환 엔진(44)에 의해 프로세싱된다.

스타일 시트 컴파일러(20)는 파서 회로(40) 및/또는 표현 프로세서(42)에 의해 사용되는 몇 개의 데이터 구조들을 메모리(18)로 출력할 수도 있다(블록 68). 파싱-시간 표현 트리 뿐만 아니라, 노드 식별자들을 일련 번호들에 매핑하는 하나 이상의 심볼 테이블들(24)도 출력될 수 있다. 예를 들어, 일 실시예에서는, 별도의 심볼 테이블들이 구성 요소 명칭들 및 속성 명칭들을 위해 출력될 수도 있다. 다른 실시예들에서는, 하나의 심볼 테이블이 출력될 수도 있다. 또한, 스타일 시트 컴파일러(20)는, 변환 엔진(44)이 템플릿 바디를 실현하기 위해 실행할 수 있는, 각각의 템플릿을 위한 한 세트의 명령어들을 가진 명령어 테이블(30)을 출력할 수도 있다. 또한, 스타일 시트(20)는, 변환 엔진에서 실행될 경우, 실행-시간 술어를 평가하는, 각각의 실행-시간 술어를 위한 명령어들도 출력할 수 있다. 또한, 스타일 시트 컴파일러(20)는 후술되는 바와 같이 템플릿 리스트 테이블(38) 및 표현 리스트 테이블(36)도 출력할 수 있다.

일부 실시예들에서는, 소정의 스타일 시트가 하나 이상의 다른 스타일 시트들을 포함할 수 있고 그리고/또는 하나 이상의 다른 스타일 시트들을 들여오기(import)할 수도 있다. 포함되는 스타일 시트(included stylesheet)는, (예를 들어, C 언어에서의 #include 문장의 취급과 유사하게) 포함되는 스타일 시트가 포함하는 스타일 시트(including stylesheet)로 물리적으로 이동된 것처럼 취급된다. 다시 말해, 포함되는 스타일 시트의 바디가 포함하는 스타일 시트의 포함하기(include) 문장을 실질적으로 대체할 수 있다. 포함되는 스타일 시트와 포함하는 스타일 시트 사이에 충돌들(예를 들어, 전역적 변수 선언들)이 존재한다면, 포함하는 스타일 시트의 정의가 사용된다. XSLT 스타일 시트들에서, 포함되는 스타일 시트는 포함하는 스타일 시트에서 xsl:include 구성 요소로 기술될 수 있다. 한편, 들여오기되는 스타일 시트는, 포함하는 스타일 시트의 문장에 의해 명시적으로 참조될 수 있는 별도의 스타일 시트로서 취급된다. 명시적 참조는, 예를 들어, (들여오기되는 스타일 시트로부터의 템플릿이 사용되는 경우의) 템플릿 매칭하기 문장에서 발생할 수 있다. 명시적 참조가 들여오기하는 스타일 시트의 다른 곳에 존재한다면, 들여오기하는 스타일 시트의 매칭 템플릿은 들여오기되는 스타일 시트의 매칭 템플릿에 우선한다. 들여오기되는 다수의 스타일 시트들이 존재하고 매칭 템플릿이 하나 이상의 들여오기되는 스타일 시트에서 발생하면, 들여오기되는 스타일 시트들이 들여오기하는 스타일 시트들에 열거되는 순서는 어떤 매칭 템플릿이 선택되는지를 제어한다(예를 들어, 매칭을 갖춘, 처음으로 나열된 들여오기되는 스타일 시트가 사용된다). XSLT 스타일 시트에서, 들여오기되는 스타일 시트는 xsl:import 구성 요소에 의해 기술될 수 있다.

"메인(main)"(들여오기하는 또는 포함하는) 스타일 시트 및 각각의 들여오기되는 또는 포함되는 스타일 시트는 스타일 시트 컴파일러(20)에 의해 독립적으로 컴파일링될 수 있다. 포함되는 스타일 시트의 경우, 메인 스타일 시트 및 포함되는 스타일 시트를 위한 데이터 구조들은, 표현 프로세서(42)에 의해 사용되는 한 세트의 데이터 구조들로 합쳐질 수도 있다. 들여오기되는 스타일 시트의 경우, 데이터 구조들은 별도의 상태를 유지할 수도 있고, 표현 프로세서(42)는 데이터 구조들을 동시에 문서에 적용할 수도 있다. 이런 실시예는, 매칭 표현들의 충돌들이 상술된 충돌 해결책을 구현하는 충돌 해결 로직에 의해 핸들링될 수 있다는 것을 제외하면, 표현 프로세서(42)의 실시예와 유사할 수 있다.

일부 실시예들에서, 스타일 시트는, 스타일 시트가 적용되고 있는 문서가 아닌 하나 이상의 문서들을 참조하는 문장들을 포함할 수도 있다. 스타일 시트는 참조되는 문서들을 프로세싱하기 위한 문장들을 더 포함할 수 있다. 일 구현에서, 스타일 시트 컴파일러(20)는, 참조되는 문서들이 무조건적으로 사용된다는 것(다시 말해, 스타일 시트가 임의의 문서에 적용되는 각 경우에서, 참조되는 문서들이 사용될 수 있다는 것)을 식별할 수 있다. 컨텐츠 변환 어플라이언스(10)는, 입력 문서의 프로세싱이 시작될 때, 무조건적으로 참조되는 문서들을 인출할 수 있고, 무조건적으로 참조되는 문서들은 그들이 스타일 시트에서 참조되는 순서대로 파싱될 수 있다. 변환 엔진(44)이 참조되는 문서를 사용하는 명령어를 실행해야 하고 참조되는 문서의 파싱이 아직 시작되지 않았다면, 변환 엔진(44)은 상이한 태스크로 문맥 전환할 수도 있다. 조건적으로 참조되는 문서들의 경우, 컨텐츠 변환 어플라이언스(10)는 그 문서를 사용하는 명령어를 실행하고자 하는 변환 엔진(44)에 응답하여 문서를 인출할 수 있고, 문서는 무조건적으로 참조되는 문서들에 대해 상술된 시점에서 파싱될 수 있다. 다른 구현들에서, 컨텐츠 변환 어플라이언스(10)는, 스타일 시트가 입력 문서에서 호출될 때, 그 스타일 시트에 대응되는 모든 참조 문서들을 인출하거나, 변환 엔진(44)이 그 참조 문서를 사용하는 명령어를 실행하고자 시도하는 것에 응답하여, 각각의 참조 문서를 인출할 수도 있다.

도 6은 스키마 컴파일러(22)의 일 실시예를 예시하는 흐름도이다. 스키마 컴파일러(22)가 소프트웨어로 구현되는 실시예들에서, 스키마 컴파일러(22)는, 실행시 도 6에 도시된 펑크션들을 구현하는 명령어들을 구비한다. 도 6의 블록들이 스키마 컴파일러(22)의 펑크션을 예시하기는 하지만, 본 흐름도가, 컴파일러가 펑크션들을 열거된 순서대로 수행하거나, 후속 펑크션을 시작하기 전에, 일 펑크션이 스타일 시트에 대해 전체적으로 완전히 실행된다는 것을 함축하는 것은 아니라는 것에 주의해야 한다.

스타일 시트 컴파일러(20)와 유사하게, 스키마 컴파일러(22)도 스키마(또는 DTD)의 노드 식별자들에 일련 번호들을 할당할 수 있다(블록 70). 스타일 시트 컴파일러(20)에 의해 소정의 노드 식별자에 할당되는 일련 번호들은 스키마 컴파일러에 의해 할당되는 일련 번호들과 동일하지 않을 수도 있다.

스키마 컴파일러(22)는 파서 회로(40)에 의한 사용을 위해 다수의 테이블들을 발생시킬 수 있다. 예를 들어, 엔티티 참조들이 문서에 포함될 수도 있고, 스키마/DTD는 엔티티들의 값을 정의할 수 있다. 엔티티 참조들을 대응되는 값들에 매핑하기 위해 DTD 엔티티 참조 테이블이 생성될 수도 있다. 또한, 스키마/DTD는, 속성을 포함할 수 있는 소정 구성 요소가 속성을 포함하지 않으면, 속성들을 위한 디폴트 값들을 특정할 수도 있다. 속성들 및 디폴트들을 기록하기 위해 DTD 디폴트 속성 리스트가 생성될 수도 있다. 또한, 허용 가능한 그리고 요구되는 문서 구조를 식별하는 골격 트리가 생성되어, 평가자에 의해 문서가 (스키마/DTD에서 정의된 바와 같이) 유효한지를 판정하는데 사용될 수도 있다. 스키마 컴파일러(22)는 심볼 테이블, DTD 테이블들, 및 골격 트리를 메모리(18)로 출력한다(블록 72).

이제 도 7을 참조하면, 파서 회로(40), 파서 회로(40)의 일 실시예를 위한 입력 데이터 구조들 및 출력 데이터 구조들이 도시되어 있다. 도시된 실시예에서, 파서 회로(40)에 의해 사용되는 입력 데이터 구조들은 DTD 엔티티 참조 테이블(34A)과 (DTD 테이블들(34)의 일부들일 수도 있는) DTD 속성 리스트(34B), 여백 테이블(32), 및 심볼 테이블들(24)을 포함할 수 있다. 파서(40)는 (문서 프로세서 구조들(39)의 일부인) 동적 심볼 테이블(39A) 및 (문서 프로세서 구조들(39)의 일부인) 한 세트의 파싱된 컨텐츠 테이블들(39B)을 생성하고 사용할 수도 있다. 좀더 구체적으로, 도시된 실시예에서, 파싱된 컨텐츠 테이블들(39B)은 골격 테이블(80), 구성 요소 인덱스 테이블(82), 구성 요소 명칭/값 테이블(84), 속성 인덱스 테이블(86), 속성 명칭/값 테이블(88), 속성 리스트(90), 프로세싱 명령어/코멘트(PI/C) 테이블(92), PI 인덱스 테이블(94), 및 구성 요소 TOC(table of contents)(96)를 포함할 수 있다. 파싱된 컨텐츠 테이블들(39B)은 변환 엔진(44)에서의 문서 변환에 사용될 수 있다. 일부 실시예들에서, 파서 회로(40)는 파싱된 컨텐츠를 파싱만의 요청들을 위한 SAX 또는 DOM 포맷들로 출력하도록 구성될 수도 있다.

파서 회로(40)는 (도 7에 나타내지 않은) 프로세서(14A)로부터 문서가 수신됨에 따라 문서를 파싱하여 파싱된 컨텐츠 테이블들(39B)을 발생시키도록 구성될 수 있다. 일반적으로, 파싱된 컨텐츠 테이블들(39B)은, 정보를 다양한 노드들로 링크하는 포인터들을 갖춘, 문서 컨텐츠의 다양한 유형들을 위한 테이블들을 구비할 수 있다. 다음에서는 도 7에 도시된 바와 같은 파싱된 컨텐츠 테이블들(39B)에 관한 세부 사항들이 제공된다. 또한, 파서 회로(40)는: (i) 문서의 각 노드를 위한 선행 및 후행 번호들을 발생시킬 수 있고; (ii) 엔티티 참조들을 DTD/스키마로 부터의 엔티티 값으로 대체할 수 있으며; (iii) (XML 스펙에서 설명된) 소정의 엔티티 참조들을 대응되는 문자들로 대체할 수 있고; (iv) DTD/스키마로부터의 디폴트 속성들 및/또는 속성 값들을 추가할 수 있으며; (v) CDATA 섹션들을 문자들로 대체할 수 있고; (vi) 스타일 시트에 의해 지시되는 대로 여백을 제거하거나 보존할 수 있으며 여백을 정규화할 수 있고; (vii) 매입된 DTD/스타일 시트들 또는 DTD/스타일 시트들에 대한 매입형 참조들을 식별할 수 있다.

엔티티 참조들을 엔티티 값들로 대체하기 위해, 파서(40)는 DTD 엔티티 참조 테이블(34A)을 사용할 수 있다. 문서에서 엔티티 참조를 막닥뜨리면, 파서 회로(40)는 DTD 엔티티 참조 테이블(34A)에서 엔티티 참조를 룩업하고 DTD 엔티티 참조 테이블(34A)로부터 대응되는 엔티티 값을 판독할 수 있다. 엔티티 값은 문서를 위해 파서 회로(40)에 의해 출력되는 파싱된 컨텐츠에서의 엔티티 참조를 대체한다. 일 실시예에서, DTD 엔티티 참조 테이블(34A)은 복수개의 엔트리들을 가진 초기 섹션을 포함할 수 있는데, 이 경우, 각 엔트리는 해싱된 엔티티 참조(예를 들어, CRC(cyclical redundancy code)-16 해시) 및, 엔티티 값을 구비하는 문자 스트링이 저장되어 있는 DTD 엔티티 참조 테이블(34A)의 제 2 섹션으로의 포인터를 저장한다. 파서 회로(40)는, 제 2 섹션에서 매칭 엔티티 값을 찾아내기 위해, 문서에서 검출되는 엔티티 참조를 해싱하고 해시를 DTD 엔티티 참조 테이블(34A)의 초기 섹션에서의 해시 값들과 비교한다.

문서에 디폴트 속성들 또는 속성 값들을 추가하기 위해, 파서 회로(40)는 DTD 속성 리스트(34B)를 사용할 수 있다. DTD 속성 리스트(34B)는 다양한 구성 요 소 명칭들을 위한 디폴트 속성들 및/또는 속성 값들을 포함할 수 있고, 파서 회로(40)는, 구성 요소를 위한 임의의 디폴트 속성들 또는 속성 값들이 포함되어 있는지를 판정하기 위해, 문서내의 구성 요소 시작 태그들에서 검출되는 구성 요소 명칭들을 룩업할 수 있다. 디폴트들이 포함되어 있다면, 파서(40)는, 구성 요소 종결이 검출될 때까지, 구성 요소 시작 태그에 포함되어 있는 속성들을 트래킹할 수 있다. DTD 속성 리스트(34B)의 속성 및/또는 속성 값이 구성 요소에 포함되어 있지 않다면, 파서 회로(40)는 DTD 속성 리스트(34B)로부터의 속성/속성 값을 삽입할 수도 있다. 일 실시예에서, DTD 속성 리스트(34B)는 해싱된 구성 요소 명칭들(예를 들어, CRC-16 해시) 및 DTD 속성 리스트(34B)의 제 2 섹션으로의 포인터들을 구비하는 초기 섹션을 가질 수도 있다. 제 2 섹션은 해싱된 속성 명칭들(예를 들어, CRC-16 해시) 및, 디폴트 속성 명칭/값이 문자 스트링으로서 저장되어 있는 DTD 속성 리스트(34B)의 제 3 섹션으로의 포인터들을 포함할 수 있다. 파서 회로(40)는 구성 요소 명칭을 해싱할 수 있고, 초기 섹션에서 해시를 룩업할 수 있으며, 제 1 부분에서 매칭이 발견되면, 제 2 섹션으로부터 해싱된 속성 명칭들 및 포인터들을 판독할 수 있다. 각각의 속성 명칭이 검출됨에 따라, 파서 회로(40)는 속성 명칭들을 해싱하고 그들을 DTD 속성 리스트(34B)로부터의 해싱된 속성 명칭들과 비교할 수 있다. 구성 요소 종결이 검출될 때, 파서 회로(40)에 의해 문서에서 검출되지 않은 임의의 해싱된 속성 명칭들은 디폴트가 필수 속성들일 수 있으며, 디폴트들은 DTD 속성 리스트(34B)의 제 3 섹션으로부터 판독되어 파싱된 컨텐츠 테이블들(39B)에 삽입될 수 있다.

여백 테이블(32)은, 어떤 구성 요소 명칭들이, 스타일 시트에서 특정되는 바와 같이, 제거된 여백을 가져야 하는지를 지시할 수 있다. 일 실시예에서, 여백이 제거될 각각의 구성 요소 명칭은 해싱될 수 있고(예를 들어, CRC-16 해시 알고리즘) 해시 값은 테이블에 저장될 수 있다. 파서 회로(40)가 문서에서 구성 요소 명칭을 검출하면, 파서 회로(40)는 구성 요소 명칭을 해싱할 수 있고 그것을 여백 테이블(32)에서 룩업할 수 있다. 매칭이 발견되면, 파서 회로(40)는 구성 요소로부터 여백을 제거할 수 있다. 그렇지 않다면, 파서 회로(40)는 구성 요소의 여백을 보존할 수 있다.

상술된 바와 같이, 심볼 테이블들(24)은 노드 식별자들을 스타일 시트 컴파일러에 의해 할당된 일련 번호들로 매핑할 수 있다. 파서 회로(40)는 심볼 테이블들(24)을 사용해 문서의 구성 요소 또는 (명칭 공간들이 사용된다면, 명칭 공간 프리픽스들에 의해 권한 부여된) 속성 명칭들을 표현 프로세서(42)로 전달하기 위한 일련 번호들로 변환한다. 그러나, 문서는 스타일 시트에서 표현되지 않은 구성 요소들 또는 속성들을 포함할 수도 있다. 이런 경우들에서, 파서 회로(40)는 일련 번호를 할당하고 일련 번호를 동적 심볼 테이블(39A)에 저장할 수 있다. 도 8의 흐름도는, 문서에서 구성 요소 또는 속성을 검출할 경우, 파서 회로(40)의 연산에 대한 일 실시예를 도시한다.

파서 회로(40)는 노드 식별자(예를 들어, 명칭 공간 프리픽스에 의해 선택적으로 프리픽싱된 구성 요소/속성 명칭)을 위해 컴파일러의 심볼 테이블들(24)을 스캐닝할 수도 있다(블록 100). 엔트리가 발견되면(판정 블록 102, "예" 분기), 파 서 회로(40)는 컴파일러의 심볼 테이블(24)로부터 일련 번호를 판독할 수 있다(블록 104). 엔트리가 발견되지 않으면(판정 블록 102, "아니오" 분기), 파서 회로(40)는 노드 식별자를 위해 동적 심볼 테이블(39A)을 스캐닝할 수도 있다(블록 106). 엔트리가 발견되면(판정 블록 108, "예" 분기), 파서 회로(40)는 동적 심볼 테이블로부터 일련 번호를 판독할 수 있다(블록 110). 엔트리가 발견되지 않으면(판정 블록 108, "아니오" 분기), 파서 회로(40)는 고유한 일련 번호(컴파일러의 심볼 테이블들(24)에도 동적 심볼 테이블(39A)에도 아직 기록되지 않은 일련 번호)를 발생시킬 수 있고, 발생된 일련 번호 및 노드 식별자로써 동적 심볼 테이블(39A)을 업데이트할 수 있다(블록 112). 어떤 경우이든, 파서 회로(40)는 일련 번호를 표현 프로세서(42)로 전송할 수 있다(블록 114).

구성 요소는 대부분, 동일 값을 가진 수 개 자식들(구성 요소들 또는 속성들)(예를 들어, 동일한 하부 구성 요소 또는 속성의 다수 인스턴스들)을 갖는다는 것에 주의한다. 따라서, 노드 식별자가 입력에서 검출되었다면, 후속의 노드 식별자가 동일할 수도 있다(또는 노드 식별자가 검출되는 후속의 수 개 명칭들에서 재발할 수도 있다). 일부 실시예들에서, 파서 회로(42)는 가장 최근에 검출된 명칭들 및 대응되는 일련 번호 중 하나 이상을 보유할 수 있고, 심볼 테이블들(24) 및 동적 심볼 테이블(39A)을 검색하기 전에, 새롭게-검출된 노드 식별자를 이들 명칭들과 비교할 수도 있다.

일부 실시예들에서는, 컴파일러 심볼 테이블들(24)의 매칭되지 않는 노드들에 대해 최적화가 적용될 수도 있다. 컴파일러가 스타일 시트의 각 노드 식별자에 일련 번호들을 할당하므로, 컴파일러의 심볼 테이블들(24)에 매칭되지 않는 노드는 파싱-시간 표현 트리(36)의 임의 노드들에도 매칭되지 않는 것으로 공지된다. 파서 회로(40)는, 일련 번호가 컴파일러의 심볼 테이블들(24)로부터 아니면 동적 심볼 테이블(39A)로부터 유래하는지의 여부에 대한 각 경우의 지시를 포함할 수도 있다. 일련 번호가 컴파일러의 심볼 테이블들(24)로부터 유래하지 않는다면, 표현 프로세서(42)는 이벤트를 파싱-시간 표현 트리(36)와 비교하지 않을 수도 있다. 표현 프로세서(42)는 다른 목적들을 위해 이벤트에 주목할 수도 있다(예를 들어, 일부 이벤트 유형들의 경우, 임의의 "/" 표현 노드 자식들은 후속 이벤트들에 의해 매칭되지 않을 수도 있다).

일 실시예에서는, 파서 회로(40)가 일련 번호(및 일부 실시예들의 경우 선행 번호)로써 발생시켜 표현 프로세서(42)로 전송할 수 있는 몇가지 이벤트들이 존재할 수 있다. 구성 요소 시작 태그가 검출되면, 구성 요소 시작 이벤트가 발생될 수 있고, 일련 번호는 구성 요소 명칭에 대응되는 일련 번호일 수 있다. 구성 요소 끝 태그가 검출되면, 구성 요소 끝 이벤트가 발생될 수 있고, 일련 번호는 구성 요소 명칭에 대응되는 일련 번호일 수 있다. 구성 요소 시작 태그에서 속성 명칭이 검출되면, 속성 명칭 이벤트가 발생될 수 있고, 일련 번호는 속성 명칭의 일련 번호일 수 있다. 구성 요소 시작 태그의 끝이 검출될 경우에는, 구성 요소 종료 이벤트(element close event)가 발생될 수 있고, 일련 번호는 구성 요소의 일련 번호일 수 있다. 표현 프로세서(42)를 위한 소정의 스타일 시트/문서 문맥을 확립하기 위해, 구성 이벤트가 발생될 수도 있다.

일 실시예에서, 심볼 테이블들(24)은 개개 문자들의 트리로서 정렬될 수도 있다. 테이블의 각 엔트리는 문자, 리프 노드 지시, 레벨의 종료 지시 및, 엔트리가 노드 식별자의 마지막 문자라면, 엔트리의 제 1 자식이나 일련 번호로의 포인터를 포함할 수 있다. 테이블의 상단에서 시작해, 명칭 또는 명칭들의 각각의 고유한 제 1 문자가 엔트리에 제공되고, 엔트리는 비-리프 노드(non-leaf node)로서 지시되며, 포인터는 명칭의 후속 문자를 저장하고 있는 제 1 엔트리로 설정된다. 포인터에서 그룹화되는 일련의 엔트리들은, 제 1 자식(제 3 문자) 등으로의 포인터들을 갖춘, 제 1 문자를 가진 명칭의 각각의 고유한 제 2 문자이다. 소정 명칭의 마지막 문자에 도달될 경우, 리프 노드 지시는, 엔트리가 리프이며 포인터 필드가 일련 번호라는 것을 지시한다. 레벨에서의 고유한 마지막 문자에 도달될 때, 시리즈의 끝은 레벨의 끝 지시에 의해 지시된다. 마찬가지로, (명칭들의 제 1 문자들을 위한) 엔트리들의 제 1 레벨 끝도 레벨의 끝 지시를 사용해 마킹될 수 있다. 따라서, 심볼 테이블들(24)을 스캐닝하는 단계는, 트리를 따라 아래쪽으로 이동하며 문자 대 문자로, 검출된 명칭을 심볼 테이블들(24)의 문자들과 비교하는 단계를 구비할 수 있다.

일 실시예에서, 동적 심볼 테이블(39A)은 약간 상이하게 편성될 수도 있다. 명칭들은 명칭의 제 1 문자에 기초해 "빈들"로 저장된다. 명칭의 각각의 가능한 제 1 문자는 동적 심볼 테이블(39A)로의 오프셋으로 사용될 수 있다. 이러한 오프셋들에서의 각 엔트리는 빈 포인터(bin pointer) 및 "빈에서의 마지막 엔트리" 포인터를 포함할 수 있다. 빈 포인터에는, 명칭의 나머지(다시 말해, 명칭의 2번째 내지 끝 문자들), 일련의 ID, 및 후속 빈 엔트리로의 포인터(다시 말해, 빈 엔트리들은 링크된 리스트일 수 있다)를 구비하는 문자열이 존재한다. 검출된 명칭은 빈 엔트리의 스트링과 비교될 수 있고, 매칭이 검출되면, 일련의 ID가 사용될 수도 있다. 그렇지 않으면, 후속의 빈 엔트리를 판독하기 위해 후속의 빈 엔트리로의 포인터가 사용된다. 매칭의 검출없이 빈의 종료에 도달되면, 명칭을 위해 새로운 엔트리가 빈에 추가된다(그리고 일련 번호가 할당된다). 특정한 일 구현에서, 각각의 빈 엔트리는 복수개의 문자들을 저장하도록 구성된 하나 이상(예를 들어, 2개)의 하부 엔트리들 및 모든 문자들이 유효하다고 정의하거나 스트링 문자의 끝이 복수개의 문자들내에 위치하는 코드를 구비할 수 있다. "빈의 마지막 엔트리" 포인터는 빈의 마지막 엔트리를 포인팅할 수 있고, 새로운 엔트리가 추가될 때, 후속의 빈 포인터를 업데이트하는데 사용될 수도 있다.

이제는 파싱된 컨텐츠 테이블들(39B)이 일 실시예를 위해 부연된다. 파서 회로(40)는 문서 구조/컨텐츠를 식별하고, 검출된 구조/컨텐츠에 기초해, 파싱된 컨텐츠 테이블들(39B)의 다양한 데이터 구조들에 문서 컨텐츠를 기입한다. 예를 들어, 파서 회로(40)는 검출된 구성 요소 명칭들(및 대응되는 구성 요소 값들/텍스트 노드들)을 구성 요소 명칭/값 테이블(84)에 저장할 수 있고 검출된 속성 명칭들(및 대응되는 값들)을 속성 명칭/값 테이블(88)에 문자 스트링들로서 저장할 수 있다. 대응되는 인덱스 테이블들(82 및 86)은, 각각, 테이블들(84 및 88)의 대응되는 문자 스트링들의 시작을 위한 포인터들을 저장할 수 있다. 인덱스 테이블들(82 및 86)은, 각각, 구성 요소의 일련 번호(도 7의 ES/N) 또는 속성(도 7의 AS/N)을 사용해 어드레싱될 수 있다.

PI/C(processing instruction/comment) 테이블(92)은 프로세싱 명령어들 및 코멘트들에 대응되는 문자 스트링들을 저장한다. 코멘트들은 구성 요소 TOC(96)에 저장되어 있는 포인터에 의해 위치가 지정되는 문자 스트링으로 저장될 수도 있다. 프로세싱 명령어들은 2개의 스트링 값들: 프로세싱 명령어 타깃 부분(확장된 명칭) 및 프로세싱 명령어 값 부분(문서로부터의 프로세싱 명령어의 나머지)을 포함할 수 있다. 프로세싱 명령어 타깃들 및 프로세싱 명령어 값들은, 구성 요소 TOC(96)로부터의 포인터에 의해 인덱싱되는 PI 인덱스 테이블(94)의 엔트리로부터의 한 쌍의 포인터들에 의해 위치가 지정될 수도 있다. PI 인덱스 테이블(94)의 엔트리들은 한 쌍의 포인터들 및 프로세싱 명령어에 할당된 일련 번호를 포함할 수 있다.

파서 회로(40)는 문서의 구성 요소 각각에 대한 속성 리스트(90)를 발생시킬 수도 있다. 속성 리스트(90)는, (존재한다면) 속성 명칭/값 테이블(88)의 속성 명칭 및 속성 값으로의 포인터들을 갖춘, (일련 번호에 의해) 그 구성 요소에 대응되는 속성들의 리스트일 수 있다. 또한, 파서 회로(40)는 각 구성 요소에 대한 구성 요소 TOC(96)를 발생시킬 수도 있다. 구성 요소 TOC(96)는 대응되는 구성 요소의 자식 노드들(예를 들어, 자식 구성 요소들, 텍스트 노드들, 코멘트 노드들, 및 프로세싱 명령어 노드들)을 식별한다. 구성 요소 TOC(96)의 각 엔트리는 (노드내의 다른 자식 구성 요소들과 비교되는 그 자식 구성 요소의 위치를 식별하는) 노드 위치, (자식 노드를 구성 요소, 텍스트, 또는 프로세싱 명령어로서 식별하는) 노드 유형, (코멘트, 프로세싱 명령어, 또는 텍스트 노드들을 위한) 노드 컨텐츠 포인터 이거나 (구성 요소 노드를 위한) 자식의 선행 번호인 필드를 포함할 수 있다. 노드 컨텐츠 포인터는 코멘트 노드를 위한 PI/C 테이블(92)로의 포인터, 프로세싱 명령어 노드를 위한 PI 인덱스 테이블(94)로의 포인터, 또는 텍스트 노드를 위한 구성 요소 명칭/값 테이블(84)로의 포인터이다. 일 실시예에서, 구성 요소 TOC(96)는 엔트리들의 링크된 리스트일 수 있으므로, 각각의 엔트리는 리스트의 후속 엔트리에 대한 포인터를 더 포함할 수도 있다.

골격 테이블(80)은 문서의 각 구성 요소 노드를 위한 엔트리를 포함할 수 있고, 구성 요소 노드의 선행 번호에 의해 인덱싱될 수 있다. 도시된 실시예에서, 골격 테이블의 임의 엔트리는 부모 노드의 선행 번호(PPREO), 구성 요소 노드를 위한 바로 직전 형제 노드의 선행 번호(IPSPREO), 구성 요소 노드의 자손인 하부 트리의 마지막 후행 번호를 지시할 수도 있는 구성 요소 노드의 후행 번호(PSTO), 구성 요소의 일련 번호(ES/N), 구성 요소 노드를 위한 속성 리스트(90)로의 속성 리스트 포인터(ALP), 구성 요소 노드를 위한 구성 요소 TOC(96)로의 TOCP(table of contents pointer), 및 (존재한다면) 구성 요소 노드를 위한 매칭 템플릿들이 열거되는 템플릿 리스트 테이블(38)의 엔트리를 포인팅하는 템플릿 리스트 포인터(TLP)를 포함한다.

상술된 다양한 데이터 구조들이 문자 스트링들을 포함한다는 것에 주의해야 한다. 일 실시예에서, 스트링 길이(예를 들어, 문자들의 수)는 스트링의 제 1 "문자"로서 저장될 수 있으며, 파서 회로(40)는 스트링 길이를 사용해 판독해야 할 문자들의 수를 판정할 수 있다.

파서 회로(40) 및 그것의 출력 데이터 구조들의 상기 예들이 XML 문서들을 위해 사용될 수도 있다. 일 실시예에서, 파서 회로(40)는 XML 문서들을 파싱하도록 설계된 하드웨어 회로를 포함한다. 일부 실시예들에서, 파서 회로(40)는 (SQL, 오라클 등과 같은) 관계 데이터베이스 구조들을 파싱하도록 설계된 하드웨어 회로도 포함할 수 있다. 파서 회로(40)는 파싱된 관계 데이터베이스 구조를 도 7에 도시된 구조와 유사한 데이터 구조로 출력할 수 있으므로, 표현 프로세서(42) 및 변환 엔진(44)이, 입력이 XML인지 아니면 관계 데이터베이스인지를 인지할 필요는 없다.

일부 실시예들에서, 파서 회로(40)는 문서들의 다른 유형들을 파싱하도록 프로그램될 수도 있다. 파서 회로(40)는 하나 이상의 입력 유형 디스크립터들을 갖도록 프로그램될 수도 있다. 입력 유형 디스크립터는, 예를 들어, 문서에서의 구조 제한자들을 설명할 수 있고; 문서가 사실상 계층 구조인지 아니면 테이블 형태인지를 지시할 수 있으며; 계층 구조 문서들이 구조의 각 레벨에 대해 명시적 인코딩들을 갖는지의 여부를 지시할 수 있고; 인코딩이 명시적이지 않다면, 구조의 끝을 검출하는 방법을 정의할 수 있으며; 존재한다면, 소정의 구조적 유닛내의 내부 구조를 정의할 수 있다.

일부 실시예들에서는, 파서 회로(40)를 위한 필터링된 문서를 발생시키기 위해, CPU들(14A-14B)에 의해 공급되는 문서를 필터링하는 선행 파서 회로가 포함될 수도 있다. 다시 말해, 파서 회로(40)는 필터를 통과하는 문서 부분만을 수신할 수 있고, 파서 회로(40)는 수신된 부분을 파싱될 전체 문서인 것으로 취급할 수 있 다. 선행 파서는, 예를 들어, 비교적 큰 입력 문서가 제공되지만 문서의 서브세트만이 관심의 대상일 경우에 사용될 수 있다. 선행 파서는 임의의 소정 방식(예를 들어, 문서의 시작으로부터 소정 갯수의 문자들을 건너 뛴 다음 다수 문자들 또는 문서의 종료에 이르기까지 포착하기; 문서 컨텐츠를 포착하기 전에 소정 구성 요소 또는 소정 갯수의 구성 요소들에 이르기까지 필터링하기; 및/또는 포착될 문서 부분들을 식별하는 좀더 복잡한 표현들(예를 들어, XPath 표현들) 등)으로 문서를 필터링하도록 프로그램될 수 있다. 선행 파서는 사용자에 의해, 스타일 시트가 문서 컨텐츠를 파기하는 효력을 가진다면, 스타일 시트 컴파일러 등으로 프로그램될 수 있다.

다음으로 도 9를 참조하면, 표현 프로세서(42), 표현 프로세서(42)의 일 실시예를 위한 입력 데이터 구조들 및 출력 데이터 구조들이 도시되어 있다. 도시된 실시예에서, 표현 프로세서(42)에 의해 사용되는 입력 데이터 구조들은 파싱-시간 표현 트리(26), 표현 리스트 테이블(36), 및 템플릿 리스트 테이블(38)을 포함한다. 표현 프로세서(42)는 몇가지 문서 프로세서 구조들(39)(특히, / 스택(39C), // 스택(39D), 포인터(Ptr) 스택(39E), 및 속성(Attr) 스택(39F))을 발생시켜 사용할 수도 있다. 표현 프로세서(42)는 템플릿/표현 매칭 리스트들(39G)을 변환 엔진(44)으로 출력할 수도 있다.

일반적으로, 표현 프로세서(42)는 파서 회로(40)로부터 이벤트들을 수신하고 거기에서 식별된 문서 노드들을 파싱-시간 표현 트리(26)의 표현 노드들에 매칭한다. 문서 노드들은, 그들이 파싱됨에 따라 인라인으로 수신된다. 따라서, 임의의 소정 시점에서, 앞서 수신된 문서 노드들은 파싱-시간 표현 트리의 매칭되는 부분들을 가질 수도 있지만, (전체 표현이 파서 회로(40)에 의해 제공되는 문서 노드들의 세트에 매칭되는 ) 트리의 리프는 아직 도착되지 않았다. 표현 프로세서(42)는 스택들(39C-39F)을 사용해, 특히, 후속 문서 노드가 비교될 수 있는 파싱-시간 표현 트리(26)의 위치를 보유하면서, 선행 문서 노드들에 대하여 매칭된 파싱-시간 표현 트리(26) 부분을 저장할 수 있다.

도시된 실시예는, 노드들간의 연산자들이 부모/자식 연산자("/") 및 자손/선조 연산자("//")를 포함할 수 있는 XPath 표현들을 위해서도 사용될 수 있다. 따라서, 소정 표현 노드는 하나 이상의 / 자식들 및 하나 이상의 // 자식들을 가질 수 있다. 소정 표현 노드가 / 자식을 가지며 문서 노드와 매칭된다면, 소정 표현 노드는 / 스택(39C)으로 푸시될 수 있다. 마찬가지로, 소정 표현 노드가 // 자식을 가지며 문서 노드와 매칭된다면, 소정 표현 노드는 // 스택(39D)으로 푸시될 수 있다. 문서 노드가 속성이라면, 그 속성은 Attr 스택(39F)에 저장될 수 있다. 일부 실시예들에서는, 이벤트를 프로세싱하기 전에 스택들의 상태가 복구될 수 있도록 하기 위해, 스택 포인터들의 상단이 이벤트 프로세싱의 시작 단계에서 보존된다. Ptr 스택(39E)은 포인터들을 저장하는데 사용될 수 있다.

실행-시간 부분들을 가진 표현들이 표현 프로세서(42)에서 부분적으로 평가되는 실시예들에서, 실행-시간 부분들에 관한 정보는 실행-시간 평가가 수행될 수 있도록 매칭 리스트들(39G)에 보유될 수 있으며, 표현의 실행-시간 부분을 충족시키지 않는 매칭 리스트들(39G)의 문서 노드들은 파기될 수 있다. 따라서, 매칭 리 스트들(39G)은 실행-시간 평가를 가진 표현의 각 부분에서 그룹화될 수 있다. 실행-시간 부분에 의해 사용되는 동일 값을 가진 각각의 문서 노드는 소정 그룹에 포함될 수 있다.

도 9에 도시된 바와 같이, 매칭 리스트들(39G)은 표현을 위한 노드 세트를 형성하는 문서 노드들의 그룹들의 계층 구조 어레이를 구비할 수도 있다. 파싱-시간 표현 트리의 각 표현을 위해 이런 구조가 존재할 수도 있다(다시 말해, 도 9에 도시된 구조는 일 표현에 대응될 수 있다). 일차 그룹(예를 들어, 도 9의 PGO 및 PG1)은 파싱-시간 표현 트리의 상부 레벨 노드에 대응될 수 있고, 상부 레벨 노드에 매칭되며 자체가 노드 세트의 멤버이거나 노드 세트의 멤버인 자식을 가진 상이한 문서 노드 각각을 위해 상이한 일차 그룹들이 존재할 수 있다. 각각의 하부 그룹 레벨은 실행-시간 평가(예를 들어, 실시예의 실행-시간 술어)에 대응될 수 있다. 실행-시간 술어를 위해 사용되는 값들은 그룹화의 후속 레벨(또는 노드 리스트 자체)을 위한 포인터로서도 보유될 수 있다. 표현을 위한 매칭이 발생할 경우, 노드는 그것의 하부 그룹 레벨들의 값들에 기초해 그룹에 배치된다. 다시 말해, 소정 레벨에서, 노드는 그것의 값이 매칭되는 하부 그룹에 포함되거나, 새로운 하부 그룹이 노드를 위해 생성된다. 도시된 실시예에서, (제 1 실행-시간 술어에 대응되는) 하부 그룹들의 제 1 레벨은 일차 그룹 0(PG0)로부터의 하부 그룹들 0 및 1(SGO 및 SG1)을 포함한다. 마찬가지로, 일차 그룹 1(PG1)은 제 1 실행-시간 술어에 대응되는 하부 그룹들(SGM 및 SGM+1)을 포함한다. 제 2 실행-시간 술어는, 하부 그룹(SG0)의 하부 그룹들로서 SGN 및 SGN+1을 포함하는, 하부 그룹들의 제 2 레 벨에 대응된다. 이 실시예에서는, 표현에 2개의 실행-시간 술어들이 존재하므로, 하부 그룹들(SGN 및 SGN+1)은 각각 잠재적인 매칭 문서 노드들(예를 들어, 도시된 실시예에서의 노드들 NO, N1, 및 N2)의 리스트들을 포인팅한다. 일 실시예에서는, 문서 노드들이 파서(40)에 의해 할당된 그들의 선행 번호에 의해 매칭 리스트들(39G)로 표현될 수도 있다.

계층 구조를 사용해, 변환 엔진(44)은 일차 그룹을 선택할 수 있고, 제 1 실행-시간 술어를 평가할 수 있으며, (제 1 실행-시간 술어를 충족시키지 않는 임의의 하부 그룹들은 파기하면서) 제 1 실행-시간 술어를 일차 그룹의 각 하부 그룹과 비교할 수 있다. 변환 엔진(44)은 제 2 실행-시간 술어를 평가할 수 있고, 제 2 실행-시간 술어를 파기되지 않은 제 1 레벨 하부 그룹들의 하부 그룹 각각과 비교할 수 있으며, 제 2 실행-시간 술어를 충족시키지 않는 하부 그룹들을 파기할 수 있는 등이다. 각각의 실행-시간 술어가 평가된 후에 구조에 남아 있는 노드들은 대응되는 표현을 충족시키는 노드 세트이다. 변환 엔진(44)은 표현에 대응되는 명령어 테이블(30)에서 명령어들을 룩업할 수 있고, 노드 세트의 노드들 각각에 대해 그 명령어들을 실행할 수 있다.

일 실시예에서, 파싱-시간 표현 트리(26)의 제 1 표현이 제 2 표현의 서픽스(suffix)라면(다시 말해, 제 2 표현이 제 1 표현에 포함되지 않은 프리픽스를 포함하지만, 제 1 표현 전체가 제 2 표현의 끝과 동일하다면), 개개 매칭 리스트(39G)가 제 1 표현을 위해 생성되지 않을 수도 있다. 대신에, 제 2 표현을 위한 매칭 리스트(39G)가 생성되고 제 1 표현의 상부-레벨 노드를 위한 그룹화를 포함한 다. 제 1 표현에 대응되는 포인터는 제 2 표현을 위한 매칭 리스트(39G)내의 제 1 표현의 상부-레벨 노드를 위한 그룹화를 포인팅할 수도 있다.

일 실시예에서, 소정 표현에 매칭되는 노드들 자체가 대응되는 템플릿 바디에 의해 조작될 수 있거나, 노드들의 값들(예를 들어, 구성 요소의 속성 값들 또는 컨텐츠)이 조작될 수 있다. 스타일 시트 컴파일러(20)는, 파싱-시간 표현 트리(26)의 각 리프 노드에 대해, 노드 또는 노드의 값이 필요한지의 여부를 지시하도록 구성될 수 있다. 일부 실시예들에서, 표현 프로세서(42)는, 각 노드에 대해, 노드가 매칭되는 템플릿들의 리스트를 출력할 수도 있다.

표현 리스트 테이블(36)은 스타일 시트에 포함되어 있는 표현들의 리스트일 수 있다. 스타일 시트 컴파일러는 표현들에 표현 번호들을 할당할 수 있고, 표현 번호들을 표현 리스트에 저장할 수 있다. 파싱-시간 표현 트리 리프 노드들의 포인터는 표현 리스트의 엔트리를 포인팅할 수 있다. 각각의 엔트리는 그룹화가 필요한 표현 트리의 레벨들을 지시하는 표현 번호 및 그룹 서명을 저장할 수 있다. 예를 들어, 일 실시예에서, 그룹 서명은 표현 트리의 각 레벨을 위한 비트를 구비할 수 있는데, 0은 그 레벨에서의 비그룹화를 지시하고 1은 그룹화를 지시한다. 일부 실시예들에서는, 하나 이상의 표현이 소정 리프 노드에 대응될 수 있다. 예를 들어, 다른 표현과의 매칭으로 인해 제거되는 컴파일링-시간 표현들은, 리프 노드에 의해 매칭되는 양 표현들의 시작을 초래할 수 있다. 또한, 소정 스타일 시트가 하나 이상의 장소에 등가 표현을 가질 수도 있다. 이런 실시예들의 경우, 매칭 표현 번호들의 리스트는 표현 리스트 테이블(36)의 연속적인 엔트리들에 저장될 수 있고, 엔트리들은 소정 리프 노드에 대한 마지막 매칭 표현을 식별할 수 있는 마지막 표현을 포함할 수 있다. 하나의 매칭 표현만이 존재한다면, 표현 포인터에 의해 포인팅되는 제 1 엔트리의 마지막 표현 지시는 자신의 마지막 엔트리 지시를 마지막 엔트리를 지시하는 상태가 되게 할 수 있다.

템플릿 리스트 테이블(38)도 마찬가지로 소정 리프 노드에 대해 다수의 매칭 템플릿들을 허용하기 위해 템플릿 번호 및 마지막 템플릿 지시를 가진 엔트리들을 포함할 수 있다. 파싱-시간 표현 트리(36)의 리프 노드들도 마찬가지로, 하나 이상의 매칭 템플릿들을 위한 템플릿 리스트 테이블로의 포인터를 포함할 수 있다. 템플릿 리스트 테이블(38)은 (예를 들어, 들여오기되거나 그렇지 않은, 템플릿이 모드 번호를 갖거나 그렇지 않은, 그리고 템플릿이 하나 이상의 실행-시간 술어들을 갖거나 그렇지 않은) 템플릿 유형 필드, 모드 번호, 들여오기되는 유형들을 위해 템플릿이 들여오기되는 스타일 시트를 식별하는 들여오기 식별자, 템플릿을 위해 실행될 명령어들을 식별하는 명령어 테이블(30)로의 템플릿 바디 명령어 포인터, 및 하나 이상의 실행-시간 술어들을 평가하기 위해 실행될 명령어들을 식별하는 명령어 테이블(30)로의 술어 포인터를 더 포함할 수 있다.

도 10은 파싱-시간 표현 트리(26) 데이터 구조의 블록도를 도시한다. 도시된 실시예에서, 파싱-시간 표현 트리는, 각 엔트리가 표현 트리의 표현 노드에 대응되는 엔트리(120)와 같은 복수개의 엔트리들을 가진 테이블을 구비할 수 있다. 각 표현 노드는 이 실시예의 경우 최대 3개까지의 상이한 유형들의 자식들을 0개 이상 가질 수 있는데, (1) / 자식들은 문서 트리에서의 노드의 자식들이거나; (2) // 자식들은 (직접적인 자식이거나 하나 이상의 노드들의 하부 트리를 거쳐 비간접적인) 문서 트리에서의 노드의 후손들이거나; (3) 속성 자식들(구성 요소 노드의 속성들)이다. 또한, 소정 표현 노드는 상부-레벨 노드일 수도 그렇지 않을 수도 있다. 일 실시예에서, 파싱-시간 표현 트리(26)는, 각각이 루트를 가진 다수 트리들의 "숲(forest)"을 구비할 수도 있다. 상부-레벨 노드는 트리들 중 하나의 루트이고, 트리는 상부-레벨 노드로 시작하는 하나 이상의 표현들을 표현할 수 있다. 상부-레벨 노드들은, 엔트리(120)와 관련하여 다음에서 부연되는 바와 같이, 후속 레벨 노드들로의 포인터들에 의해, 파싱-시간 표현 트리 데이터 구조의 상단에서 그룹화될 수 있다.

다음에서는 엔트리(120)의 필드들이 설명된다. 엔트리(120)는 상부-레벨 표현 노드들에 사용되는 TLT(top-level type) 필드를 포함한다. 상부 레벨 유형은 상대적, 절대적, 또는 선조로 인코딩될 수 있다. 상대적 상부-레벨 노드는, 문서 트리의 문맥 노드와 관련하여 평가되는 하나 이상의 표현들을 시작하는 표현 노드인 반면, 절대적 상부-레벨 노드는, 문서 트리의 루트 노드로부터 평가되는 하나 이상의 표현들을 시작하는 표현 노드이다(다시 말해, 표현 또는 표현들은 상부-레벨 노드 식별자가 수반되는 /로써 시작한다). 선조의 상부-레벨 노드는 문맥 노드의 선조들을 참조하는 표현의 시작이다(다시 말해, 표현 또는 표현들은 상부-레벨 노드 식별자가 수반되는 //로써 시작한다).

엔트리(120)는 표현 노드의 일련 번호를 저장하는 일련 번호(S/N) 필드를 포함한다. S/N 필드는, 엔트리(120)에 저장되어 있는 표현 노드에 대한 매칭(동일한 일련 번호들) 또는 미스매칭을 검출하기 위해, 파서 회로(40)에 의해 전송되는 이벤트들에서 식별되는 문서 노드들의 일련 번호들과 비교된다. 엔트리(120)는, 엔트리(120)에 저장되어 있는 표현 노드가 리프 노드인지의 여부(즉, 표현의 종료에 도달되었는지의 여부)를 식별하는 리프 노드(LN) 필드를 더 포함한다. 리프 노드에 대한 매칭은, 문서 노드가 리프 노드에 대응되는 각각의 표현/템플릿을 위한 매칭 리스트들(39G)에 기록되게 한다. LN 필드는, 예를 들어, 설정될 경우, 표현 노드가 리프 노드라는 것을 지시하고, 소거될 경우, 표현 노드가 리프 노드가 아니라는 것을 지시하는 비트일 수 있다. 다른 실시예들은 비트의 설정 또는 소거 의미들을 반전할 수 있거나 다른 인코딩들을 사용할 수도 있다.

경로 유형 필드는 엔트리(120)에 저장되어 있는 표현 노드로부터의 경로 링크들의 유형(예를 들어, /, //, 또는 양자)을 식별할 수 있다. 예를 들어, 경로 유형 필드는, 경로 유형이 발생한다는 것을 지시하기 위해 설정될 수 있으며 그 경로 유형이 발생하지 않는다는 것을 지시하기 위해 소거될 수 있는, 각 유형을 위한 비트를 포함할 수 있다. 다른 실시예들은 비트의 설정 또는 소거 의미들을 반전할 수 있거나 다른 인코딩들을 사용할 수도 있다. 경로 유형 필드는 "Ptr/" 및 "Ptr//" 필드들을 평가할 수 있다. Ptr/ 필드는 표현 노드의 제 1 / 자식으로의 포인터를 포함할 수 있다(그리고 / 자식들 각각은 Ptr/ 포인터에 의해 지시되는 엔트리에서 시작하는 파싱 시간 표현 트리 데이터 구조의 연속적인 엔트리들로 그룹화될 수 있다). 마찬가지로, Ptr// 필드는 표현 노드의 제 1 // 자식으로의 포인터를 저장할 수 있다(그리고 // 자식들 각각은 Ptr// 포인터에 의해 지시되는 엔트 리에서 시작하는 파싱 시간 표현 트리 데이터 구조의 연속적인 엔트리들로 그룹화될 수 있다). Ptr Attr 필드는 파싱-시간 표현 트리의 제 1 속성 노드로의 포인터를 저장할 수 있다(그리고, 속성들 각각은 Ptr Attr 포인터에 의해 지시되는 엔트리에서 시작하는 파싱-시간 트리 데이터 구조의 연속적인 엔트리들로 그룹화될 수 있다).

EOL 필드는, 엔트리(120)가 현재 트리 레벨의 끝인 표현 노드를 저장하는지의 여부에 대한 지시를 저장한다. 예를 들어, 레벨의 끝을 지시하는 파싱-시간 표현 트리 데이터 구조의 상단으로부터의 제 1 엔트리는 마지막 상부-레벨 노드를 지시할 수 있다. 각 포인터(예를 들어, Ptr/, Ptr//, 또는 Ptr Attr)에서 시작해, 엔트리들은, 레벨의 끝을 지시하는 EOL 필드를 가진 엔트리에 도달될 때까지, 포인터를 포함하는 엔트리의 자식들이다. EOL 필드는, 예를 들어, 설정될 경우, 표현 노드가 레벨의 끝임을 지시하고, 소거될 경우, 표현 노드가 레벨의 끝이 아니라는 것을 지시하는 비트일 수 있다. 다른 실시예들은 비트의 설정 및 소거 의미들을 반전할 수 있거나 다른 인코딩들을 사용할 수도 있다.

엔트리(120)는, 상술된 바와 같이, 표현 리스트 테이블(36)의 엔트리를 포인팅하는 표현 리스트 포인터를 저장하는 표현 리스트 포인터(XLP) 필드 및 템플릿 리스트 테이블(38)의 엔트리를 포인팅하는 템플릿 리스트 포인터를 저장하는 템플릿 리스트 포인터(TLP) 필드를 더 포함한다. XLP 및 TLP 필드들은 리프 노드들을 위해 유효할 수 있다.

일부 술어들은 본 실시예의 파싱-시간에서 평가 가능할 수 있고, 술어 유형(PrTP) 필드 및 술어 데이터(PrDT) 필드는 이런 술어들을 표현하는데 사용될 수 있다. 예를 들어, 술어 유형 필드는 평가 불가능한 술어, 위치 술어, 또는 속성 명칭 술어를 나타내도록 인코딩될 수도 있다. 술어 데이터 필드는 표현으로부터의 술어 데이터(예를 들어, 위치 술어를 위한 위치 번호 또는 속성 명칭 술어를 위한 속성 명칭이나 속성 명칭을 위한 일련 번호)를 저장할 수 있다.

도 11은 예시적인 표현 트리(122) 및 표현 트리(122)에 대응되는 파싱-시간 표현 트리 엔트리들(120A-120E)의 대응되는 부분들에 대한 블록도이다. 표현 트리(122)는, 2개의 / 자식 노드들(124B 및 124C;일련 번호들(15 및 20)), 하나의 // 자식 노드(124D;일련 번호(25)), 및 속성 자식(124E;일련 번호(30))을 가진 일련 번호(10)의 표현 노드(124A)를 포함한다. 따라서, 표현 트리(122)는 (노드 124A가 상대적 상부-레벨 노드라고 가정하면) 다음 표현들: 10/15, 10/20, 10//25, 및 10/attribute::30을 표현한다.

엔트리들(120A-120E)은 파싱-시간 표현 트리 엔트리들의 S/N, LN, EOL, Ptr/, Ptr//, 및 Ptr Attr 필드들을 예시한다. 엔트리(120A)는 노드(124A)에 대응됨으로써, 일련 번호(10)를 포함한다. 노드(124A)는 리프 노드가 아니므로, 엔트리(120A)의 LN 필드는 0이다. 이 실시예의 경우, 노드(124A)가 트리(122)의 그 레벨에서의 유일한 노드이므로, EOL 필드는 1이다. 엔트리(120A)의 Ptr/ 필드는 엔트리(120B)(제 1 / 자식)을 포인팅한다. 엔트리(120A)의 Ptr// 필드는 엔트리(120D)를 포인팅하고, 엔트리(120A)의 Ptr Attr 필드는 엔트리(120E)를 포인팅한다.

엔트리(120B)는 S/N 필드에 15를 포함하고, 노드(124B)는 표현 트리(122)의 리프 노드이므로, LN 필드는 1이다. 그러나, 이 레벨에 다른 / 자식이 존재하므로, EOL 필드는 0이다. 엔트리(120B)의 Ptr/, Ptr//, 및 Ptr Attr 필드들은, 엔트리(120B)가 리프 노드이므로, 널(null)이다. 엔트리(120C)는 S/N 필드에 20을 포함하고, 노드(124C)는 표현 트리(122)의 리프 노드이므로, LN 필드가 1이다. 노드(124C)는 이 레벨에서의 마지막 / 자식이므로, EOL 필드 또한 1이다. 이번에도, 엔트리(120C)는 리프 노드이므로, 엔트리(120C)의 Ptr/, Ptr//, 및 Ptr Attr 필드들은 널이다.

엔트리(120D)는 S/N 필드에 25를 포함하고, 노드(124D)는 표현 트리(122)의 리프 노드이므로, LN 필드는 1이다. 노드(124D)는 이 레벨에서의 마지막 // 자식이므로, EOL 필드 또한 1이다. 엔트리(120D)는 리프 노드이므로, 엔트리(120D)의 Ptr/, Ptr//, 및 Ptr Attr 필드들은 널이다.

엔트리(120E)는 S/N 필드에 30을 포함하고, 노드(124E)는 표현 트리(122)의 리프 노드이므로, LN 필드는 1이다. 노드(124E)는 이 레벨에서의 마지막 속성 자식이므로, EOL 필드는 1이다. 엔트리(120E)는 리프 노드이므로, 엔트리(120E)의 Ptr/, Ptr//, 및 Ptr Attr 필드들은 널이다.

다음으로 도 12A-12B, 도 13, 도 14A-14B, 및 도 15를 참조하면, 파서 회로(40)에 의해 발생될 수 있는 이벤트들 각각에 대한 표현 프로세서(42)의 일 실시예의 연산을 도시하는 흐름도들이 도시되어 있다. 각 이벤트는 검출된 문서 노드의 일련 번호를 포함할 수 있다(그리고, 일부 실시예들에서는, 문서 노드의 선행 번호도 포함할 수 있다). 표현 프로세서(42)는 하드웨어로 구현될 수도 있으므로, 다양한 블록들이, 필요에 따라, 하드웨어에서 병렬로 또는 하드웨어에서 파이프라인으로 수행될 수 있다고 하더라도, 흐름도들은 하드웨어의 연산을 표현할 수 있다. 흐름도들은 일반적으로 문서 노드들과 표현 노드들을 매칭하는 단계를 의미할 수 있다. 앞서 언급된 바와 같이, 이러한 매칭 단계는 문서 노드들과 표현 노드들의 일련 번호들을 매칭하는 단계를 구비할 수도 있다. 또한, 흐름도들은 노드들을 매칭 리스트들로 출력하는 단계를 의미할 수 있다. 앞서 언급된 바와 같이, 노드들이, 일부 실시예들에서는, 선행 번호에 의해 매칭 리스트들로 표현될 수도 있다.

도 12A 및 도 12B는 구성 요소 시작 이벤트에 따른 표현 프로세서(42)의 일 실시예의 연산을 도시한다. 구성 요소 시작 이벤트는 문서에서 구성 요소 시작 태그를 검출하는 것에 응답하여 전송될 수 있다.

표현 프로세서(42)는 / 스택(39C)에 저장될 수 있는 임의의 속성 표현 노드들을 파핑(popping)할 수 있고, / 스택 포인터를 포인터 스택(39E)으로 푸시(push)할 수 있다(블록 130). 새로운 구성 요소가 시작되고 있으므로, / 스택상의 임의의 속성 표현 노드들은 매칭되지 않을 것이며, 따라서 불필요하다. (도 12A 및 도 12B의 설명에서는 좀더 간결하게 구성 요소로서 참조되는) 구성 요소 시작 이벤트에 의해 식별되는 구성 요소가 문서의 루트 노드라면(판정 블록 132, "예" 분기), 추가적인 프로세싱은 수행되지 않는다. 루트 노드는 파싱-시간 표현 트리(26)의 노드들 중 어떤 것과도 매칭되지 않으며, 임의의 상부 레벨 노드들이 루트의 자식들과 매칭될 수 있다. 구성 요소가 루트 노드는 아니지만(판정 블록 132, "아니 오" 분기) 구성 요소의 부모가 루트 노드라면(판정 블록 134, "예" 분기), 루트 노드의 자식에 대한 절대적 상부-레벨 노드들에 대해서도 매칭이 검출될 수 있으므로, 표현 프로세서(42)는 파싱-시간 표현 트리(26)의 상부-레벨 표현 노드 각각을 점검할 수 있다(블록 136). 한편, 구성 요소 노드의 부모 구성 요소가 루트 노드가 아니라면(판정 블록 134, "아니오" 분기), 루트 노드의 자식이 아닌 노드에 대한 절대적 상부-레벨 노드들에 대해서는 매칭이 검출되지 않을 수도 있으므로, 표현 프로세서(42)는 파싱-시간 표현 트리(26)의 상대적 상부-레벨 표현 노드 각각을 점검할 수 있다(블록 138).

상부-레벨 노드들 중 어떤 것에 대해서도 매칭이 검출되지 않으면(판정 블록 140, "아니오" 분기), 흐름도는 도 12B의 참조 부호 A에서 계속된다. 매칭이 검출되고(판정 블록 140, "예" 분기), 표현 노드가 리프 노드이면(판정 블록 142, "예" 분기), 구성 요소 노드는 파싱 시간 표현 트리(26)의 표현 노드 엔트리에서의 XLP 및 TLP 포인터들에 의해 포인팅되는 표현(들) 및/또는 템플릿(들)에 대응되는 매칭 리스트로 출력된다(블록 144). 매칭된 표현 노드가 리프 노드가 아니라면(판정 블록 142, "아니오" 분기), 표현 프로세서(42)는, 매칭된 표현 노드가 임의의 / 또는 // 자식들을 가지고 있는지를 판정하고(각각, 판정 블록들 146 및 148), 매칭된 표현 노드가 임의의 / 또는 // 자식들을 가지고 있다면(각각, 블록들 150 및 152), 매칭된 표현을, 각각, / 스택(39C) 및/또는 // 스택(39D)으로 푸시한다. 또한, / 스택(39C) 및 // 스택(39D)은 (파싱-시간 표현 트리 엔트리의 PrTP 및 PrDT 필드들을 통해 지시되는) 파싱-시간 술어들의 매칭을 관리하는데 사용되는 평가 필드를 포함할 수도 있다. (PrTP 필드에 의해 지시되는 바와 같이) 파싱-시간 술어가 존재하면, 평가 필드는 0으로 설정될 수 있다. 그렇지 않으면, 평가 필드는 2로 설정될 수 있다. 흐름도는 도 12B의 참조 부호 A에서 계속된다.

도 12B의 참조 부호 A에서, 흐름도는, 흐름도를 통한 이 통과가 이 구성 요소를 위한 / 스택(39C)의 제 1 점검인지의 여부에 따라(판정 블록 154), 상이하게 동작한다. 이것이 이 구성 요소를 위한 / 스택(39C)의 제 1 점검이라면(판정 블록 154, "예" 분기), 표현 프로세서(42)는, 구성 요소의 부모가 / 스택(39C)에서의 매칭인지를 판정한다(판정 블록 156). 구성 요소의 부모가 / 스택(39C)에서의 매칭이라면(판정 블록 156, "예" 분기), 매칭된 표현 노드의 / 자식들 중 하나가 구성 요소와 매칭될 수 있다. 표현 프로세서(42)는, 매칭된 표현 노드의 파싱-시간 표현 트리 엔트리에서의 Ptr / 에 의해 지시되는 바와 같이, 매칭된 표현 노드의 제 1 자식을 인출할 수 있고(블록 158), / 자식에서 매칭이 검출되는지를 판정하기 위해(그리고, 매칭이 검출되면 도 12A에 블록들(142-152)로서 도시된 바와 같이 프로세싱하기 위해) 도 12A의 참조 부호 B로 복귀할 수 있다. 구성 요소의 부모가 / 스택에서의 매칭이 아니라면(판정 블록 156, "아니오" 분기), 표현 프로세서(42)는 // 스택(39D)을 점검할 수 있다(블록 160). 마찬가지로, 이 통과가 이 구성 요소를 위한 / 스택(39C)의 제 1 점검이 아니고(판정 블록 154, "아니오" 분기) 마지막 / 자식이 / 스택에서의 매칭된 표현 노드로부터 인출되었다면(판정 블록 162, "예" 분기), 표현 프로세서(42)는 // 스택(39D)을 점검할 수 있다(블록 160). 이 통과가 이 구성 요소를 위한 / 스택(39C)의 제 1 점검이 아니고(판정 블록 154, "아니 오" 분기) 마지막 / 자식이 / 스택의 매칭된 표현 노드로부터 인출되지 않았다면(판정 블록 162, "아니오" 분기), 표현 프로세서(42)는 / 스택의 매칭된 표현 노드에 대한 후속의 / 자식을 인출할 수 있고, 흐름도는, 구성 요소에 대해 매칭이 검출되는지를 판정하기 위해 도 12A의 참조 부호 B에서 계속될 수 있다. 따라서, 블록들(154-164)의 연산(및 도 12A의 블록들(140-152)로 복귀하는 것)을 통해, 구성 요소의 부모와 매칭되는 표현 노드의 / 자식 각각이 구성 요소에 의한 매칭을 위해 검색될 수 있다.

일부 실시예들에서는, 구성 요소의 부모 구성 요소가 표현 프로세서(42)에 의해 보유될 수 있다(예를 들어, 표현 프로세서(42)는 구성 요소 시작 이벤트는 발생하였지만 구성 요소 끝 이벤트는 발생하지 않은 구성 요소들의 스택을 유지할 수 있다). 다른 방법으로, 다른 실시예들에서는, 부모 구성 요소가 파서 회로(40)에 의해 보유될 수 있으며 구성 요소 시작 이벤트에 포함될 수 있다.

// 스택(39D)을 검색하는 단계는 본 실시예의 / 스택(39C)을 검색하는 단계와는 다소 상이한 프로세싱을 수반할 수 있다. (// 연산자는 표현 노드의 임의 자손을 선택하고 // 스택(39D)상의 엔트리들은 구성 요소 시작 이벤트에서 식별된 구성 요소의 부모 또는 선조인 선행 구성 요소와 매칭되었으므로) 노드는 // 스택(39D)상의 임의의 표현 노드에 대한 // 자식과 매칭될 수 있다. 따라서, 도 12B의 흐름도는 // 스택(39D)상의 유효 엔트리 각각의 // 자식들을 검색하는 단계를 예시한다.

// 스택(39D)이 유효 엔트리들을 가지고 있지 않다면(또는 더 이상의 유효 엔트리들을 가지고 있다면)(판정 블록 166, "아니오" 분기), // 스택 프로세싱은 종결되고 구성 요소 시작 이벤트의 프로세싱은 종결된다. // 스택(39D)이 유효 엔트리를 가지고 있다면(판정 블록 166, "예" 분기), 표현 프로세서(42)는, 엔트리의 Ptr //에 의해 지시되는 바와 같이, 엔트리의 제 1 // 자식을 인출한다(블록 168). 표현 프로세서(42)는, 매칭이 검출되는지를 판정하기 위해(판정 블록 170), // 자식을 구성 요소와 비교한다. 매칭이 검출되고(판정 블록 170, "예" 분기), // 자식 노드가 리프 노드라면(판정 블록 172, "예" 분기), 구성 요소는, 블록 144와 유사하게, 매칭 리스트들로 출력된다(블록 174). 블록들(146-152)과 유사하게, // 자식 노드가 리프 노드가 아니고 매칭이 검출되면, 표현 프로세서(42)는, // 자식 노드가 임의의 / 또는 // 자식들 자체를 가지고 있는지를 판정하고(각각, 판정 블록들 176 및 178), // 자식 노드가 임의의 / 또는 // 자식들을 가지고 있다면(각각, 블록들 180 및 182), // 자식 노드를 / 스택(39D) 및/또는 // 스택(39D)으로 푸시한다. 또한, / 또는 // 스택(39C-39D)의 평가 필드는 블록들(146-152)과 관련하여 상술된 바와 같이 설정될 수 있다.

현재의 // 스택 엔트리의 마지막 자식이 프로세싱되지 않았다면(판정 블록 184, "아니오" 분기), 표현 프로세서(42)는 현재의 // 스택 엔트리를 위한 후속의 // 자식을 인출하고(블록 186), 흐름도는 후속의 // 자식을 위해 판정 블록 170에서 계속된다. 마지막 자식이 프로세싱되었다면(판정 블록 184, "예" 분기), 표현 프로세서(42)는 // 스택(39D)의 후속 엔트리로 진행하고(블록 188), 흐름도는 후속의 // 스택 엔트리를 위해 판정 블록 166에서 계속된다.

도 13은 구성 요소 종료 이벤트에 따른 표현 프로세서(42)의 일 실시예의 연산을 도시한다. 구성 요소 종료 이벤트는 문서에서 구성 요소 끝 태그를 검출하는 것에 응답하여 파서 회로(40)에 의해 전송될 수 있다.

구성 요소 종료 이벤트가 문서의 루트 노드를 위한 것이라면(판정 블록 190, "예" 분기), 문서는 종결된다(블록 192). 표현 프로세서(42)는 스택들(39C-39F)을 소거할 수 있다. 구성 요소 종료 이벤트가 문서의 루트 노드를 위한 것이 아니라면(판정 블록 190, "아니오" 분기), 표현 프로세서(42)는 종료 구성 요소(ending element)에 대응되는 / 및 // 스택 엔트리들을 파핑할 수 있다(블록 194). 구성 요소가 종료되고 있으므로, 구성 요소의 모든 자식들은 이미 파싱된 상태이다. 따라서, 구성 요소에 대응되는 / 및 // 스택의 임의 엔트리들(다시 말해, 구성 요소의 일련 번호를 가진 엔트리들)은 후속적으로 검출되는 노드들에 의해 매칭될 수 없다.

도 14A 및 도 14B는 속성 명칭 이벤트에 따른 표현 프로세서(42)의 일 실시예의 연산을 도시한다. 속성 명칭 이벤트는, 문서의 구성 요소 시작 태그내에서 속성 명칭을 검출하는 것에 응답하여 파서 회로(40)에 의해 전송될 수 있다. 속성 명칭은 그것의 일련 번호에 의해 표현될 수 있다.

표현 프로세서(42)는 속성 명칭(즉, 그것의 일련 번호)을 Attr 스택(39F)으로 푸시할 수 있다. Attr 스택(39F)은 구성 요소 종료 명령 프로세싱(도 15)을 위해 속성 명칭들을 누적한다. 속성의 부모 노드가 루트 노드라면(판정 블록 202, "예" 분기), (루트 노드는 속성들을 갖지 않으므로) 추가적인 프로세싱은 수행되지 않는다. 한편, 속성의 부모 노드가 루트 노드가 아니라면(판정 블록 202, "아니오" 분기), 표현 프로세서(42)는 계속된다.

표현 프로세서(42)는 속성 명칭에 대한 매칭(또한, 일련 번호에 의한 매칭)을 위해 상대적 상부-레벨 표현 노드들 각각을 점검할 수 있다(블록 204). 소정의 상대적 상부-레벨 표현 노드와의 매칭이 존재하지 않으면(판정 블록 206, "아니오" 분기), 상부-레벨 표현 노드들이 소진될 때까지(판정 블록 208, "아니오" 분기), 프로세싱은 후속의 상대적 상부-레벨 표현 노드로써 계속된다. 일단 상부-레벨 표현 노드들이 소진되고 나면(판정 블록 208, "예" 분기), 프로세싱은 도 14B의 참조 번호 C에서 계속된다.

매칭이 검출되고(판정 블록 206, "예" 분기) 노드가 리프 노드이면(판정 블록 208, "예" 분기), 속성 노드는 매칭 리스트들(39G)로 출력된다(블록 210). 표현 프로세서(42)는 매칭된 표현 노드가 임의의 / 또는 // 자식들을 가지고 있는지를 판정하고(각각, 판정 블록들 212 및 214), 매칭된 표현 노드가 임의의 / 또는 // 자식들을 가지고 있다면(각각, 판정 블록들 216 및 218), 매칭된 표현 노드를, 각각, / 스택(39C) 및/또는 // 스택(39D)으로 푸시한다.

도 14B의 참조 부호 C에서 계속하면, 표현 프로세서(42)는 / 또는 // 스택(39C-39D)의 속성 명칭에 대한 부모 노드의 매칭을 위해 점검한다(판정 블록 220). 매칭들이 검출되지 않으면(판정 블록 220, "아니오" 분기), 속성 명칭 이벤트의 프로세싱은 종결된다. 매칭이 검출되면, 표현 프로세서(42)는, 매칭되는 포현 노드가 속성 명칭 술어(또는, 일 실시예의 경우, 예약된 인코딩)을 가지고 있는 지를 판정하기 위해, 매칭되는 표현 노드의 표현 트리 엔트리에 대한 PrTP 필드를 점검한다. 매칭되는 표현 노드가 속성 명칭 술어를 가지고 있으며 평가 필드의 LSB(least significant bit)가 소거되어 있다면(다시 말해, 평가 필드가 0 또는 2라면)(판정 블록 222, "예" 분기), 표현 프로세서(42)는 속성 명칭을 매칭되는 표현 노드의 표현 트리 엔트리에 대한 PrDT 필드와 비교할 수 있다. 속성이 매칭을 가지고 있지 않으면(판정 블록 224, "아니오" 분기), 표현 프로세서(42)는, 존재한다면, / 또는 // 스택(39C-39D)에서의 후속의 매칭 노드로써 계속한다. 속성이 매칭을 가진다면(판정 블록 224, "예" 분기), 일 실시예에서, 표현 프로세서(42)는, PrTP 필드가 예약된 인코딩을 가지고 있는지를 확인하기 위해 점검한다(판정 블록 226). 다른 실시예들에서는, 판정 블록 226이 생략될 수도 있다. PrTP 필드가 예약된 인코딩을 가지고 있다면(판정 블록 226, "예" 분기), 표현 프로세서(42)는 / 또는 // 스택(39C-39D)의 매칭 표현 노드를 위한 평가 필드 비트 1을 설정할 수 있다(블록 228). PrTP 필드가 예약된 인코딩을 가지고 있지 않다면(판정 블록 226, "아니오" 분기), 표현 프로세서(42)는 평가 필드를 3으로 설정할 수 있다(블록 230). 어떤 경우이든, 속성 명칭 이벤트의 프로세싱은 종결될 수 있다. 일부 실시예들에서는, 표현 프로세서(42)가 속성 값 매칭을 수행하고자 시도할 경우에, 예약된 인코딩이 사용될 수도 있다. 다른 실시예들은 이런 매칭을 수행하지 않을 수도 있고, 이런 실시예들에서, 블록들(226 및 228)은 생략될 수도 있다.

판정 블록 222의 "아니오" 분기를 따라가면, 표현 프로세서(42)는, PrTP 필드가 비 파싱-시간 술어 또는 위치 술어를 지시하는지를 판정한다(판정 블록 232). 다시 말해, 표현 프로세서(42)는, PrTP 필드가 속성 명칭을 지시하는지의 여부를 판정한다. PrTP 필드가 비 파싱-시간 술어 또는 위치로 코딩되어 있지 않으면(판정 블록 232, "아니오" 분기), 표현 프로세서(42)는 후속의 매칭되는 / 또는 // 스택 엔트리로 이동하거나, 더 이상의 매칭 엔트리들이 존재하지 않으면, 프로세싱을 종료한다(각각, 판정 블록 234의 "예" 및 "아니오" 분기들). PrTP 필드가 비 파싱-시간 술어 또는 위치로 코딩되어 있으면, 표현 프로세서(42)는, 표현 노드가 속성 자식을 가지고 있는지를 판정한다(판정 블록 236). 표현 노드가 속성 자식을 가지고 있지 않으면(판정 블록 236, "아니오" 분기), 표현 프로세서(42)는 후속의 매칭되는 / 또는 // 스택 엔트리로 이동하거나, 더 이상의 매칭 엔트리들이 존재하지 않으면, 프로세싱을 종료한다(각각, 판정 블록 234의 "예" 및 "아니오" 분기들). 표현 노드가 속성 자식을 가지고 있다면(판정 블록 235, "예" 분기), 표현 프로세서(42)는 속성 자식을 인출하고(블록 238) 속성 자식을 속성 명칭(일련 번호)과 비교한다. 속성 자식이 속성 명칭과 매칭되고(판정 블록 240, "예" 분기) 속성 자식 노드가 리프 노드이면(판정 블록 242, "예" 분기), 표현 프로세서(42)는 속성 명칭 노드를 매칭 리스트들(39G)로 출력한다. 속성 매칭의 검출 여부와 상관없이, 추가적인 속성 자식들의 노드들이 존재하면(다시 말해, 속성 자식 노드의 EOL 지시가 레벨의 끝을 지시하지 않으면)(판정 블록 246, "예" 분기), 표현 프로세서(42)는 후속의 속성 자식 노드를 인출하고(블록 238) 블록들(240-244)로써 계속한다. 그렇지 않으면(판정 블록 246, "아니오" 분기), 표현 프로세서(42)는 후속의 매칭되는 / 또는 // 스택 엔트리로 이동하거나, 더 이상의 매칭 엔트리들이 존재하지 않 으면, 프로세싱을 끝낸다(각각, 판정 블록 234의 "예" 및 "아니오" 분기들).

도 15는 구성 요소 종료 이벤트에 따른 표현 프로세서(42)의 일 실시예의 연산을 도시한다. 구성 요소 종료 이벤트(element close event)는, 구성 요소 시작 태그의 종료를 검출하는 것에 응답하여 파서 회로(40)에 의해 전송될 수 있다(그리고, 그에 따라, 구성 요소의 모든 속성들은 이 구성 요소를 위한 문서에서 검출되었다). 구성 요소 종료 이벤트에 응답하여, 표현 프로세서(42)는 / 스택(39C)에서의 임의의 매칭 노드들의 속성 자식들에 대하여 파서 회로(40)에 의해 앞서 식별된 속성 명칭들을 점검한다.

종료되고 있는 구성 요소의 부모 노드가 루트 노드라면(판정 블록 250, "예" 분기), 추가적인 프로세싱은 수행되지 않는다. 종료되고 있는 구성 요소의 부모 노드가 루트 노드가 아니라면(판정 블록 250, "아니오" 분기), 표현 프로세서는 속성 명칭을 지시하는 PrTP 필드를 가진 엔트리들을 위해 / 스택(39C)을 점검한다(블록 252). 매칭 엔트리들이 발견되지 않으면(판정 블록 254, "아니오" 분기), 프로세싱은 종결된다. 매칭 엔트리가 발견되고(판정 블록 254, "예" 분기) 매칭 엔트리의 평가 필드가 3이 아니면(판정 블록 256, "예" 분기), 프로세싱은 역시 종결된다. 매칭 엔트리가 발견되고(판정 블록 254, "예" 분기) 매칭 엔트리의 평가 필드가 3이면(판정 블록 256, "예" 분기), 프로세싱은 블록 258에서 계속된다.

표현 프로세서(42)는 매칭 표현 노드의 속성 자식을 인출한다(블록 258). 또한, 표현 프로세서(42)는 속성 스택(39F)을 위한 속성 명칭도 인출한다(블록 260). 표현 프로세서(42)는 속성 명칭들을 비교한다. 매칭이 검출되면(판정 블록 262, "예" 분기), 속성 노드는 매칭 리스트들(39G)로 출력된다(블록 264). 어떤 경우이든, 속성 스택(39F)의 끝에 도달되지 않았다면(판정 블록 266, "아니오" 분기), 프로세싱은 속성 스택(39F)의 후속 속성을 위해 블록 260에서 계속된다. 속성 스택(39F)의 끝에 도달되었고(판정 블록 266, "예" 분기) 매칭 표현 노드의 마지막 속성 자식이 프로세싱되지 않았다면(판정 블록 268, "아니오" 분기), 프로세싱은 매칭 표현 노드의 후속의 속성 자식을 위해 블록 258에서 계속된다. 속성 스택(39F)의 끝에 도달되었고(판정 블록 266, "예" 분기) 매칭 표현 노드의 마지막 속성 자식이 프로세싱되었다면(판정 블록 268, "예" 분기), 구성 요소 종료 이벤트의 프로세싱은 종결된다.

도 12A-12B, 도 13, 도 14A-14B, 및 도 15에 대한 상기 설명에서의 여러 포인트들에서, 흐름도들은 노드를 매칭 리스트들(39G)로 출력하는 단계를 언급한다는 것에 주의한다. 노드를 출력하는 연산은 노드를 파싱-시간 표현 트리(26)의 매칭된 리프 노드에 대응되는 표현들/템플릿들의 노드 설정 구조(들)에 삽입하는 단계를 포함할 수 있다. 노드를 출력하는 연산은 파서 회로(40)에 의해 발생된 골격 트리를 파싱-시간 표현 트리(26)의 리프 노드에서의 템플릿 리스트 포인터에 의해 지시되는 바와 같이 템플릿 번호(또는 리스트)로써 업데이트하는 단계를 더 포함할 수 있다.

상기 여러 포인트들에서, 표현 노드는 / 스택(39C) 또는 // 스택(39D)으로 푸시되는 것으로 언급될 수 있다는 것에 주의한다. 표현 노드를 스택(39C-39D)으로 푸시하는 단계는 노드의 표현 트리 엔트리(120)(또는 표현 매칭에 사용된 표현 트리 엔트리 부분)를 스택으로 푸시하는 단계를 포함할 수 있다. 필요에 따라, 추가 정보(예를 들어, 평가 필드와 같은, 매칭들의 진행을 지시하는 여러 상태 변수들)가 엔트리에 포함될 수도 있다.

다음으로 도 16을 참조하면, 문서를 위한 파싱된 컨텐츠 테이블들(39B) 및 매칭 리스트들(39G)을 수신하는 것에 따른 변환 엔진(44)의 일 실시예에 대한 연산을 예시하는 흐름도가 도시되어 있다. 변환 엔진(44)은 하드웨어로 구현될 수 있고, 따라서, 다양한 블록들이, 필요에 따라, 하드웨어에서 병렬로 또는 하드웨어에서 파이프라인으로 수행될 수 있음에도 불구하고, 흐름도는 하드웨어의 연산을 표현할 수 있다.

각 표현을 위해, 변환 엔진(44)은 표현에 대한 임의의 실행-시간 부분들(예를 들어, 일 실시예의 실행-시간 술어들)을 평가할 수 있다(블록 270). 예를 들어, 일 실시예에서, 템플릿 리스트 테이블(38)의 포인터는 실행-시간 술어들을 평가하기 위해 변환 엔진(44)에 의해 실행될 명령어 테이블(30)의 명령어들을 지시할 수 있다. 다른 실시예들에서는, 실행-시간 술어들이 다른 방식들(예를 들어, 파싱-시간 표현 트리(26)와 유사한 실행-시간 표현 트리)로 식별될 수 있다. 실행-시간 술어 평가에 응답하여, 변환 엔진(44)은 실행-시간 표현들을 충족시키는 노드 설정 구조로부터 그룹들을 선택할 수 있다(블록 272). 변환 엔진(44)은 표현들에 대응되는 명령어 테이블(30)로부터의 명령어들을 실행할 수 있다(예를 들어, 명령어들은 템플릿 리스트 테이블(38)의 템플릿 바디 포인터에 의해 위치 지정될 수 있다). 명령어들은 선택된 그룹들의 노드들 각각에 대해 실행될 수 있고(블록 274), 결과들은 출력 발생기(46)로 출력될 수 있다(블록 276).

일 실시예에서, 변환 엔진(44)은 스타일 시트 컴파일러(20)에 의해 발생된 명령어들을 실행하도록 설계된 복수개의 하드웨어 프로세서들을 구비할 수 있다. 다시 말해, 프로세서들의 명령어 세트가 정의될 수 있고, 스타일 시트 컴파일러(20)는 명령어 세트의 명령어들을 발생시킬 수 있다. 일부 실시예들에서는, 명령어 세트가 XSLLT 언어로의 확장들을 수용하도록 설계된다. 변환 엔진(44)은, 예를 들어, 특정 노드에 대해 실행될 명령어들을, 결과들을 발생시키기 위해 그 노드에 대해 명령어를 실행할 수 있는 프로세서들 중 하나로 디스패치(dispatch)할 수 있다.

일 실시예에서, 실행-시간 술어들을 평가하기 위해 실행되는 명령어들은, 유사한 술어들(예를 들어, 공통의 프리픽스 부분들을 가진 술어들)이 동시에 평가되도록 정렬됨으로써, 술어를 평가하기 위한 노드들의 인출이 최소화될 수 있다. 예를 들어, 매칭 노드의 후속 노드들에 기초하는 술어들은 함께 그룹화되어 동시에 평가될 수 있다.

일부 경우들에서, 스타일 시트의 변수들 및/또는 파라미터들은 표현을 사용해 선언될 수 있고, 이후의 명령어들은 변수들/파라미터들을 사용할 수 있다. 변수들/파라미터들을 정의하는 표현들은 파싱-시간 표현 트리(26)에 포함될 수 있으므로, 표현들은 표현 프로세서(42)에 의해 평가될 수 있다(또는 표현들이 실행-시간 술어들을 포함한다면, 부분적으로 평가될 수 있다). 실행-시간 술어들은 다른 실행-시간 술어들과 유사하게 평가될 수 있다. 일부 실시예들에서, 스타일 시트 컴파일러(20)는, 명령어가 변수들/파라미터들이 평가되기 전에 변환 엔진(44)에 의해 시도될 가능성을 감소시키기 위해, 변수들/파라미터들을 사용하는 명령어들 훨씬 전에 변수들/파라미터들을 평가하기 위한 명령어들을 정렬하고자 할 수 있다. 변환 엔진(44)은, 예를 들어, 변수들/파라미터들을 사용하며 명령어들 및 변수들/파라미터들이 평가되기 전에 시도되는 명령어들이 배치될 수 있는 대기 큐를 포함할 수 있고, 명령어들은, 변수들/파라미터들이 평가될 때까지, 재시도될 수 있고 대기 큐로 원위치될 수 있다. 다른 실시예들에서, 스타일 시트 컴파일러(20)는 다양한 변수들/파라미터들에 의존하는 명령어들을 명시적으로 식별할 수 있고, 변환 엔진(44)은 각 명령어를 실행하려고 시도하기 전에 이러한 의존성들을 점검할 수 있다. 또 다른 실시예들에서, 스타일 시트 컴파일러(20)는, 소정 명령어가 그것의 의존성들이 충족되기 전에 실행되지 않는다는 것을 보장하기 위해, 명령어들을 재정렬할 수 있다. 예를 들어, 스타일 시트 컴파일러(20)는 명령어들의 망 형태로 정렬된 데이터 의존성 그래프(topologically sorted data dependency graph)를 구성할 수 있고, 소정 레벨의 각 명령어에 그룹 번호를 할당할 수 있다. 변환 엔진(44)은, 선행 그룹들의 모든 명령어들이 실행을 위해 선택될 때까지, 소정 그룹 번호를 가진 소정 명령어를 선택하지 않을 수도 있다.

상술된 다양한 데이터 구조들로의 (그리고 다양한 데이터 구조들내로의) 포인터들은, 필요에 따라, (단독으로 포인팅되는 데이터를 특정하는) 풀 포인터들(full pointers)일 수 있거나 포인팅되는 데이터를 포함하고 있는 구조의 베이스 어드레스로부터의 오프셋들일 수도 있다는 것에 주의한다.

표현 프로세서, 추가 실시예

다음에서는, 도 17 내지 도 24B를 참조하여 표현 프로세서(42)의 다른 실시예가 설명된다. 이 실시예는 다소 상이한 파싱-시간 표현 트리 구조를 사용할 수 있으며, 추가 표현들을 핸들링할 수 있다. 이 실시예는 XML 노드 구조들을 사용하지만, 다른 실시예들은 다른 마크업 언어들을 이용할 수도 있다. 도 17 내지 도 24B를 통해 도시된 실시예는, 문서 체제에서 발견된 노드들을 사용해 평가될 수 있는 술어들을 포함하는 임의 노드들(예를 들어, 구성 요소들, 속성들, 프로세싱 명령어들, 코멘트들, 텍스트 등)에서 매칭될 수 있다. 흐름도들은 일반적으로 문서 노드들 및 표현 노드들을 매칭하는 단계를 언급할 수 있다. 앞서 언급된 바와 같이, 이런 매칭은 문서 노드들과 표현 노드들의 일련 번호들을 매칭하는 단계를 구비할 수 있다. 또한, 흐름도들은 노드들을 매칭 리스트들로 출력하는 단계를 언급할 수 있다. 앞서 언급된 바와 같이, 노드들이, 일부 실시예들에서는, 매칭 리스트들에서 선행 번호에 의해 표현될 수도 있다.

도 17은, 엔트리(300)를 포함하여, 파싱-시간 표현 트리(26)의 다른 실시예를 도시하는 블록도이다. 엔트리(300)는 도면의 공간 원인들로 인해 도 17에 2개의 로우들로서 도시되어 있다. 엔트리(300)는 파싱-시간 표현 트리(26)의 일 표현 노드에 대응될 수 있으므로, 각각의 표현 노드를 위해 엔트리(300)와 유사한 엔트리가 존재할 수도 있다.

엔트리(300)는, 도 10에 도시된 엔트리(120)와 유사하게, TLT(top-level type) 필드, S/N(serial number) 필드, LN(leaf node) 필드, EOL(end of level) 필 드, XLP(expression list pointer) 필드, TLP(template list pointer) 필드, PrTP(predicate type) 필드, 및 PrDT(predicate data) 필드를 포함한다. 또한, 엔트리(300)는 NT(node type) 필드, CD(child descriptor) 필드, Ptr/ 필드, Ptr// 필드, Ptr/Attr 필드, Ptr//Attr 필드, Ptr/PI 필드, 및 Ptr//PI 필드도 포함할 수 있다. 도 17에 도시된 필드들의 순서가 메모리에서의 필드들의 순서에 대응되지 않을 수도 있다는 것에 주의한다. 오히려, 엔트리(300)의 필드들은 단지 파싱-시간 표현 트리 엔트리에 대한 일 실시예의 컨텐츠들을 예시하기 위해 도시된 것일 뿐이다.

엔트리(300)에 대응되는 표현 노드는 다양한 유형들의 자식 표현 노드들을 가질 수도 있다. 엔트리(300)의 CD 필드는, 표현 노드가 어떤 유형들의 자식 표현 노드들을 가지고 있는지에 대한 지시를 저장할 수 있다. 예를 들어, 도 18은 CD 필드의 인코딩에 대한 일 실시예를 도시하는 테이블(302)을 포함한다. 도 18에 도시된 실시예에서, CD 필드는 각각의 자식 노드 유형을 위한 그리고 그 유형의 / 또는 // 자식을 위한 비트를 포함할 수 있다. 예를 들어, 도시된 실시예에는 6개의 자식 노드 유형들(구성 요소, 속성, 텍스트, 코멘트, 프로세싱 명령어(PI), 및 PI-리터럴(processing instruction with a literal))이 존재한다. 각 유형은 표현 노드의 / 자식 또는 // 자식일 수 있으므로, 이 실시예에서 CD 필드는 12개 비트들을 구비한다. 대응되는 비트가 설정되어 있으면, 표현 노드는 소정 유형에 대한 하나 이상의 자식 표현 노드를 가진다(/ 또는 //). 예를 들어, 표현 노드가 하나 이상의 / 자식 구성 요소 노드를 가지면, CD 필드의 비트 11이 설정될 수 있다. 표현 노드가 하나 이상의 // 자식 구성 요소 노드를 가지면, CD 필드의 비트 10이 설정될 수 있다. 다른 실시예들은 설정 및 소거 상태들의 의미를 반전할 수 있거나 임의의 소정 인코딩을 사용할 수도 있다. CD 필드는, 표현 매칭 프로세스의 일부로서, 소정 표현 노드가 소정 유형에 대한 임의의 자식들을 가지고 있는지를 판정하는데 사용될 수 있다.

NT 필드는 엔트리(300)에 대응되는 표현 노드의 유형을 식별하는 노드 유형을 저장할 수 있다. 예를 들어, 도 18은 NT 필드를 위한 예시적 인코딩을 예시하는 테이블(304)을 포함한다. 예시적 실시예에서, NT 필드는, 그것의 2진 값들이 테이블(304)의 왼쪽 컬럼에 도시되어 있는 3 비트 인코딩을 구비할 수 있다. 오른쪽 컬럼은 이 실시예를 위한 다양한 노드 유형들(예를 들어, 구성 요소, 속성, 텍스트, 코멘트, PI, 노드, 및 타깃을 갖춘 PI)을 열거한다. 다른 실시예들은 임의의 다른 인코딩을 사용할 수 있고, 도시된 유형들의 서브세트(subset) 또는 수퍼세트(superset)를 지원할 수도 있다.

도시된 실시예에서, 엔트리(300)는 파싱-시간 표현 트리(26)의 자식 노드 엔트리들로의 6개 포인터들을 포함할 수 있다. Ptr/Attr 포인터는 표현 노드의 / 자식들인 속성 노드들을 포인팅할 수 있다. / 속성 자식 노드들은 Ptr/Attr 포인터에 의해 지시되는 엔트리에서 시작하는 파싱-시간 표현 트리(26)로 그룹화될 수 있다. Ptr//Attr 포인터는 표현 노드의 // 자식들인 속성 노드들을 포인팅할 수 있다. // 속성 자식 노드들은 Ptr//Attr 포인터에 의해 지시되는 엔트리에서 시작하는 파싱-시간 표현 트리(26)로 그룹화될 수 있다. Ptr/PI 포인터는, 표현 노드의 / 자식들인 PI 노드들을 포인팅할 수 있다. /PI 자식 노드들은 Ptr/PI 포인터에 의해 지시되는 엔트리에서 시작하는 파싱-시간 표현 트리(26)로 그룹화될 수 있다. Ptr//PI 포인터는 표현 노드의 // 자식들인 속성 노드들을 포인팅할 수 있다. //PI 자식 노드들은 Ptr//PI 포인터에 의해 지시되는 엔트리에서 시작하는 파싱-시간 표현 트리(26)로 그룹화될 수 있다. 표현 노드의 다른(즉, PI 노드들의 속성이 아닌) / 자식 노드들은 (표현 노드의 / 자식들을 위한) Ptr/ 포인터에서 그리고 (표현 노드의 // 자식들을 위한) Ptr// 포인터에서 파싱-시간 표현 트리(26)로 그룹화된다.

도시된 실시예는 속성 자식들, 프로세싱 명령어 자식들, 및 나머지 자식들을 위치 지정하기 위한 포인터들의 개별 세트들을 제공하지만, 다른 실시예들은 포인터들의 상이한 세트들을 구현할 수 있다. 예를 들어, 실시예는 포인터들의 단 하나의 세트: 각각, 모든 / 자식들 및 모든 // 자식들을 위치 지정하기 위한 / 포인터 및 // 포인터만을 포함할 수 있다. 다른 실시예들은, 필요에 따라, 각 노드 유형을 위해 / 및 // 포인터들을 구현할 수 있거나 포인터들에서의 노드들을 다른 방식들로 그룹화할 수도 있다.

PrTP 필드는, 이 실시예에서, 도 18의 테이블(306)에 도시된 바와 같은, 인코딩을 가질 수 있다. 술어 유형들은, 이 실시예에서, 비 술어(또는 좀더 구체적으로, 비 파싱-시간 평가 가능 술어), 위치 술어, 구성 요소 자식 술어, 속성 명칭 술어, 명칭을 갖춘 PI 노드 테스트 술어, 노드 테스트 술어, 코멘트 노드 테스트 술어, PI 노드 테스트 술어, 및 텍스트 노드 테스트 술어를 포함할 수 있다. 노드 테스트 술어는 단순히, (임의 유형의) 노드가 표현 노드의 자식 또는 자손으로서 존재한다는 것을 테스트할 수 있다. 코멘트 노드 테스트, (명칭이 없는) PI 노드 테스트, 및 텍스트 노드 테스트 술어들은 소정 유형의 노드에 대한 존재를 테스트할 수 있다. 명칭을 갖춘 PI 노드 테스트는 명칭을 가진 PI 타깃을 갖춘 PI 노드의 존재를 테스트할 수 있다. 다른 실시예들은 임의의 다른 인코딩을 사용할 수 있으며, 도시된 술어 유형들의 서브세트 또는 수퍼세트를 지원할 수도 있다.

일부 실시예들에서, 표현 리스트 테이블(36) 및 템플릿 리스트 테이블(38)은 도 9와 관련하여 상술된 것과 유사한 구성을 가질 수 있다. 또한, 일 실시예에서, 각각의 템플릿 리스트 테이블 엔트리는, (적용 가능하다면) 그 템플릿 리스트 테이블 엔트리에 대응되는 템플릿 매칭 표현에서 어떤 자식 노드가 참조되고 있는지를 식별하는 노드 ID를 포함할 수 있다. 예를 들어, 템플릿 리스트 테이블(38)은, 소정 표현 또는 표현들을 위해 매칭된 마지막 구성 요소에 따라 편성될 수 있다(다시 말해, 표현이 구성 요소의 비-구성 요소 자식들을 포함하는 경우라 하더라도, 테이블은 구성 요소에 의해 매칭된 표현들의, 마지막 구성 요소를 위한, 리스트를 포함할 수 있다). 그 구성 요소 노드를 위한 표현 리스트의 표현들 중 일부에 포함될 수 있는 속성, 텍스트, 코멘트, 또는 프로세싱 명령어 자식 노드들은 노드 ID에 의해 식별될 수 있다. 노드 ID는 자식 노드의 유형을 식별할 수 있다. 또한, 속성들 및 프로세싱 명령어들의 경우, 노드 ID는, 각각, 노드내의 다른 속성들 및 프로세싱 명령어들에 관련한 위치를 식별할 수 있다. 0의 노드 ID는, 대응되는 표현을 위한 구성 요소 노드의 자식이 존재하지 않는다는 것을 지시할 수 있다.

이 실시예에서, 파서 회로(40)는 표현 프로세서(42)를 위해 다음의 이벤트들: 상부 레벨 구성 요소 시작 이벤트, 구성 요소 시작 이벤트, 구성 요소 끝 이벤트, 속성 명칭 이벤트, 텍스트 이벤트, 코멘트 이벤트, 프로세싱 명령어 이벤트, 및 구성 이벤트를 발생시킬 수 있다. 구성 이벤트는 표현 프로세서(42)를 위해 소정의 스타일 시트/문서 문맥을 확립하도록 발생될 수 있다.

상부 레벨 구성 요소 시작 이벤트는, 루트의 자식인 구성 요소의 시작을 식별할 수 있다. 루트가 아닌 다른 구성 요소들의 자식들인 구성 요소들의 시작은 구성 요소 시작 이벤트에 의해 식별된다. 예를 들어, XML을 이용하는 실시예들에서, 구성 요소 시작 이벤트들은, 구성 요소 시작 태그가 검출되었다는 것을 지시할 수 있다. 각각의 이벤트는 구성 요소의 일련 번호를 포함할 수 있다. 일부 실시예들에서, 이벤트들은 구성 요소의 자식 위치 및/또는 구성 요소의 선행 번호를 포함할 수도 있다. 이들 이벤트들은, 표현 프로세서(42)로 하여금 구성 요소를 파싱-시간 표현 트리(26)에서의 표현들에 매칭하는 것을 시도하게 할 수 있다.

구성 요소 및 이벤트는 구성 요소의 끝을 검출하는 것(예를 들어, XML을 이용 중인 실시예들에서는 구성 요소 끝 태그가 검출된 것)에 응답하여 발생될 수 있다. 표현 프로세서(42)는 그것의 구성 요소 끝 이벤트에 응답하여 구성 요소에 의해 매칭된 임의의 표현 분기들을 플러시(flush)할 수 있다.

속성 명칭 이벤트는 속성 명칭을 검출하는 것에 응답하여 발생될 수 있다. 속성 명칭 이벤트는 속성 명칭의 일련 번호를 포함할 수 있고, 일부 실시예들에서는, 구성 요소가 대응되는 속성의 선행 번호를 포함할 수도 있다. 표현 프로세 서(42)는 속성 명칭 이벤트에 응답하여 표현 트리의 표현들에 대한 속성 명칭의 매칭을 시도할 수도 있다.

텍스트 이벤트는 문서에서 텍스트를 검출하는 것에 응답하여 발생될 수 있다. 텍스트 이벤트는 대응되는 구성 요소의 선행 번호를 포함할 수도 있고, 표현 프로세서(42)로 하여금 텍스트 노드 테스트 또는 텍스트 표현 노드에서의 매칭을 위해 표현 트리의 표현들을 점검하게 할 수 있다. 마찬가지로, 코멘트 이벤트는 문서에서 코멘트 노드를 검출하는 것에 응답하여 발생될 수 있다. 코멘트 이벤트는 대응되는 구성 요소의 선행 번호를 포함할 수 있고, 표현 프로세서(42)로 하여금 코멘트 노드 테스트 또는 코멘트 표현 노드에서의 매칭을 위해 표현 트리의 표현들을 점검하게 할 수 있다.

프로세싱 명령어 이벤트는 프로세싱 명령어를 검출하는 것에 응답하여 발생될 수 있다. 프로세싱 명령어 이벤트는 프로세싱 명령어의 일련 번호를 포함할 수 있고, 일부 실시예들에서는, 대응되는 구성 요소의 선행 번호를 포함할 수도 있다. 표현 프로세서(42)는, 리터럴(literal)을 갖추거나 갖추지 않은, 프로세싱 명령어 노드 테스트 또는 프로세싱 명령어 표현 노드에 대한 프로세싱 명령어 매칭을 시도할 수 있다.

다음으로 도 19A 및 도 19B를 참조하면, (구성 요소 시작 및 상부 레벨 구성 요소 시작 이벤트들 모두를 포함하여) 구성 요소 시작 이벤트에 응답하여, 도 17에 도시된 파싱-시간 표현 트리를 사용하는, 표현 프로세서(42)의 일 실시예의 연산을 예시하는 흐름도가 도시되어 있다. 일반적으로, 프로세싱은 구성 요소와의 매칭을 위해 상대적 상부 레벨 표현 노드들(및, 이벤트가 상부 레벨 구성 요소 시작 이벤트라면, 비-상대적 상부 레벨 표현 노드들)을 점검하는 단계 뿐만 아니라 구성 요소가 / 및 // 스택들(39C 및 39D)상의 표현 노드에 대한 술어를 충족시키는지의 여부 또는 이런 표현 노드의 구성 요소 자식인지의 여부를 점검하는 단계도 포함할 수 있다.

표현 프로세서(42)는 포인터 스택(39E)으로 / 및 // 스택 포인터들을 푸시할 수 있다(블록 310). 좀더 구체적으로, 도시된 실시예에서, 포인터 스택(39E)은, 각각, / 스택 포인터들 및 // 스택 포인터들을 위한 /Ptr 스택 및 //Ptr 스택을 구비할 수 있다. 다른 방법으로, 다른 실시예들은 양자의 포인터들을 동일 스택으로 푸시할 수도 있다. 포인터들은, 대응되는 구성 요소 끝 이벤트가 발생할 때, (종료되고 있는 구성 요소 이전에 매칭된 표현들에 다른 구성 요소가 매칭될 수 있게 하면서) / 스택(39C) 및 // 스택(39D)의 상태를 구성 요소의 검출 이전 상태로 복구하기 위해 후속적으로 파핑될 수 있다. 구성 요소 시작 이벤트에 의해 식별된 구성 요소가 도 19A 및 도 19B의 설명에서는 좀더 간략하게 구성 요소로서 언급될 것이다. 상부 레벨 구성 요소 시작 이벤트가 수신되었는지의 여부에 따라(판정 블록 312), 표현 프로세서(42)는 매칭을 위해 파싱-시간 표현 트리의 (예를 들어, 절대적 및 선조 상부-레벨 표현 노드들을 포함하는) 상부-레벨 표현 노드 각각을 점검할 수 있거나(블록 316) 상대적 상부-레벨 표현 노드 각각을 점검할 수 있다(블록 314). 다시 말해, 이벤트가 상부 레벨 구성 요소 시작 이벤트라면(판정 블록 312, "예" 분기), 루트 노드의 자식을 위한 절대적 상부-레벨 노드들에 대해서도 매칭이 검출될 수 있으므로, 표현 프로세서(42)는 파싱-시간 표현 트리(26)의 상부-레벨 표현 노드 각각을 점검할 수 있다(블록 316). 한편, 이벤트가 상부 레벨 구성 요소 시작 이벤트가 아니라면(판정 블록 312, "아니오" 분기), 매칭이 절대적 상부-레벨 노드들에 대해서는 검출될 수 없으므로, 표현 프로세서(42)는 상대적 상부-레벨 표현 노드 각각을 점검할 수 있다(블록 314).

상부 레벨 노드들 중 어떤 것에 대해서도 매칭이 검출되지 않으면(판정 블록 318, "아니오" 분기), 흐름도는 도 19B의 참조 부호 D에서 계속된다. 매칭이 검출되고(판정 블록 318, "예" 분기) 표현 노드가 리프 노드라면(판정 블록 320, "예" 분기), 구성 요소 노드는 파싱-시간 표현 트리(26)의 표현 노드 엔트리에서의 XLP 및 TLP 포인터들에 의해 포인팅되는 표현(들) 및/또는 템플릿(들)에 대응되는 매칭 리스트로 출력된다(블록 322). 표현 프로세서(42)는, 매칭된 표현 노드가 임의의 / 또는 // 자식들을 가지고 있는지를 판정하고(각각, 판정 블록들 324 및 326), 매칭된 표현 노드가 임의의 / 또는 // 자식들을 가지고 있다면, 매칭된 표현 노드를, 각각, / 스택(39C) 및/또는 // 스택(39D)으로 푸시한다(각각, 블록들 328 및 330). 표현 프로세서(42)는, / 또는 // 자식들이 존재하는지의 여부를 검출하기 위해, 예를 들어, 파싱-시간 표현 트리(26)의 표현 노드 엔트리에 대한 CD 필드를 사용할 수 있다. 또한, / 스택(39C) 및 // 스택(39D)은 (파싱-시간 표현 트리 엔트리(300)의 PrTP 및 PrDT 필드들에 의해 지시되는) 파싱-시간 술어들의 매칭을 관리하는 데 사용되는 평가 필드를 포함할 수도 있다. (0이 아닌 PrTP 필드에 의해 지시되는 바와 같이) 파싱-시간 술어가 존재하면, 평가 필드는 0으로 설정될 수 있 다. 그렇지 않으면, 평가 필드는 1로 설정될 수 있다. 흐름도는 도 19B의 참조 부호 D에서 계속된다.

도 19B의 참조 부호 D에서는, 구성 요소가 (/ 또는 // 스택 엔트리들 중 하나에 저장되어 있는) 앞서 매칭된 표현 노드의 자식 또는 술어와 매칭되는지를 확인하기 위해, / 및 // 스택들이 검색된다. / 및 // 스택들이 공백이라면(판정 블록 332, "예" 분기), 이 구성 요소를 위한 매칭은 결말이 난다. 그렇지 않으면(판정 블록 332, "아니오" 분기), 스택 엔트리가 선택된다. 엔트리의 평가 필드가 1로 설정되어 있으면, 선택된 스택 엔트리의 대응되는 표현 노드는 술어를 가지고 있지 않거나 앞서 파싱된 문서 노드에 의해 술어가 충족된 상태이다. 따라서(판정 블록 334, "Eval=1" 분기), 표현 프로세서는, 구성 요소가 구성 요소 자식들 중 어떤 것과 매칭되는지를 판정하기 위해, 선택된 스택 엔트리의 표현 노드에 대한 임의의 구성 요소 자식들을 점검할 수 있다. / 구성 요소 자식들 및 // 구성 요소 자식들 모두가 고려될 수 있다. 좀더 구체적으로, 표현 노드가 (예를 들어, 파싱-시간 표현 트리(300)의 CD 필드에서 지시되는 바와 같이) 구성 요소 자식을 가지고 있지 않으면(판정 블록 336, "아니오" 분기), 구성 요소를 위한 매칭 프로세스는 결말이 난다. 다른 방법으로, 표현 프로세서(42)는 프로세싱을 위해 후속의 스택 엔트리로 진행할 수도 있다(블록 362). 표현 노드가 구성 요소 자식을 가지고 있다면(판정 블록 336, "예" 분기), 표현 프로세서(42)는 표현 노드의 제 1 구성 요소 자식을 인출한다(블록 338). 예를 들어, 엔트리의 Ptr/ 또는 Ptr// 포인터들이 (자식 표현 트리 엔트리들의 NT 유형 필드와 함께) 구성 요소 자식들을 위치 지정 하는데 사용될 수 있다. 자식 구성 요소 노드가 구성 요소와 매칭되고(블록 340, "예" 분기) 자식 구성 요소 노드가 리프 노드라면(판정 블록 342, "예" 분기), 노드는 매칭 리스트로 출력된다(블록 344). 또한, 매칭된 자식 구성 요소 노드가, 각각, / 또는 // 자식들을 가지고 있다면(판정 블록 346 및 348), 매칭된 자식 구성 요소 노드는, 각각, / 스택(39C) 또는 // 스택(39D)으로 푸시되고(블록 350 및 352), Eval 필드는 블록들( 324-330)과 관련하여 상술된 바와 같이 초기화된다. 자식 구성 요소 노드가 구성 요소와 매칭되는지에 관계없이, 표현 프로세서(42)는 마지막 구성 요소 자식이 프로세싱되었는지를 판정한다(판정 블록 354). 아니라면, 후속의 자식 구성 요소 노드가 인출되어(블록 338), 유사한 방식으로 프로세싱된다. 자식 구성 요소 노드가 현재 스택 엔트리의 마지막 구성 요소 자식이라면(판정 블록 354, "예" 분기), 표현 프로세서(42)는 후속의 스택 엔트리로 진행할 수 있고(블록 362) 구성 요소 자식들 및 술어들 모두를 프로세싱할 수 있다.

선택된 스택 엔트리의 PrTP 필드가 4 또는 구성 요소 자식과 동일하면, 구성 요소는 선택된 스택 엔트리의 표현 노드에 대한 술어를 충족시킬 수 있다. 따라서(판정 블록 334, "PrTP=4" 분기), 표현 프로세서(42)는 구성 요소 일련 번호를 선택된 스택 엔트리의 PrDT 필드와 비교할 수 있다(블록 356). 구성 요소가 PrDT 필드와 매칭되면(판정 블록 358, "예" 분기), 구성 요소는 술어를 충족시키고 표현 프로세서(42)는 선택된 스택 엔트리의 Eval 필드를 1로 설정한다(블록 360). 어떤 경우이든, 표현 프로세서(42)는 후속의 스택 엔트리로 진행할 수 있다(블록 362).

소정 스택 엔트리가 0의 Eval 필드 및 4가 아닌 PrTP 필드를 가질 수도 있다 는 것에 주의한다. 이런 경우, 표현 프로세서(42)는 후속의 스택 엔트리로 진행할 수 있다(블록 362).

이제 도 20을 참조하면, 구성 요소 끝 이벤트에 응답하여, 도 17에 도시된 파싱-시간 표현 트리(26)를 사용하는, 표현 프로세서(42)의 일 실시예의 연산을 예시하는 흐름도가 도시되어 있다.

구성 요소 끝 이벤트가 문서의 루트 노드를 위한 것이라면(판정 블록 370, "예" 분기), 문서는 종결된다(블록 372). 표현 프로세서(42)는 스택들(39C-39F)을 소거할 수 있다. 구성 요소 끝 이벤트가 문서의 루트 노드를 위한 것이 아니라면(판정 블록 370, "아니오" 분기), 표현 프로세서(42)는 Ptr 스택(39E)으로부터 / 및 // 스택 포인터들을 파핑할 수 있다(블록 374). 구성 요소가 끝나고 있으므로, 구성 요소의 모든 자식들은 이미 파싱되었다. 따라서, 구성 요소에 대응되는 / 및 // 스택의 임의 엔트리들(다시 말해, 구성 요소의 일련 번호를 가진 엔트리들)은 후속적으로 검출되는 노드들에 의해 매칭될 수 없다. 사실상, 구성 요소를 위한 구성 요소 시작 이벤트가 검출되었을 때 푸시된 / 및 // 스택 포인터들을 복구하는 단계는, 결말이 나고 있는 구성 요소에 대응되는 / 및 // 스택들(39C-39D)상의 엔트리들을 파핑하고 그들의 상태를 (검출된 후속의 구성 요소를 프로세싱하기 위한 정확한 상태일 수 있는) 그 구성 요소를 프로세싱하기 이전의 상태로 복구한다.

이제 도 21A 및 도 21B를 참조하면, 속성 명칭 이벤트에 응답하여, 도 17에 도시된 파싱-시간 표현 트리(26)를 사용하는, 표현 프로세서(42)의 일 실시예의 연산을 예시하는 흐름도가 도시되어 있다. 속성 명칭 이벤트에 의해 식별된 속성이 도 21A 및 도 21B에 대한 설명에서는 "속성"으로서 언급될 수도 있다. 일반적으로, 이 프로세싱은 속성과의 매칭을 위해 상대적 상부-레벨 표현 노드들을 점검하는 단계 뿐만 아니라 속성이 / 및 // 스택들(39C 및 39D)상의 표현 노드에 대한 술어를 충족시키는지의 여부 또는 이런 표현 노드의 속성 자식인지의 여부를 점검하는 단계도 포함할 수 있다.

속성의 부모 노드가 루트 노드라면(판정 블록 382, "예" 분기), (루트 노드는 속성들을 가지고 있지 않으므로) 추가 프로세싱은 수행되지 않는다. 한편, 속성의 부모 노드가 루트 노드가 아니라면(판정 블록 382, "아니오" 분기), 표현 프로세서(42)는 계속된다.

표현 프로세서(42)는 속성에 대한 매칭을 위해 상대적 상부-레벨 표현 노드들 각각을 점검할 수 있다(블록 384). 소정의 상대적 상부-레벨 표현 노드와의 매칭이 존재하고(판정 블록 386, "예" 분기) 노드가 리프 노드라면(판정 블록 388, "예" 분기), 속성 노드는 매칭 리스트들(39G)로 출력된다(블록 390). 매칭의 존재 여부에 상관없이, 프로세싱은, 상부-레벨 표현 노드들이 소진될 때까지(판정 블록 392, "아니오" 분기), 후속의 상대적 상부-레벨 표현 노드로써 계속될 수 있다. 일단, 상부-레벨 표현 노드들이 소진되고 나면(판정 블록 392, "예" 분기), 프로세싱은 도 21B의 참조 부호 E에서 계속된다.

도 21B의 참조 부호 E에서 계속하면, 속성이 (/ 또는 // 스택 엔트리들 중 하나에 저장되어 있는) 앞서 매칭된 표현 노드의 자식 또는 술어와 매칭되는지를 확인하기 위해, / 및 // 스택들이 검색된다. / 및 // 스택들이 공백이면(판정 블 록 394, "예" 분기), 이 속성을 위한 매칭은 결말이 난다. 그렇지 않으면(판정 블록 394, "아니오" 분기), 스택 엔트리가 선택된다. 엔트리의 평가 필드가 1로 설정되어 있으면, 선택된 스택 엔트리의 대응되는 표현 노드는 술어를 가지고 있지 않거나 앞서 파싱된 문서 노드에 의해 술어가 충족된 상태이다. 따라서(판정 블록 334, "Eval=1" 분기), 표현 프로세서(42)는, 속성이 속성 자식들 중 어떤 것과 매칭되는지를 판정하기 위해, 선택된 스택 엔트리의 표현 노드에 대한 임의의 속성 자식들을 점검할 수 있다. / 및 // 속성 자식들 모두가 고려될 수 있다. 좀더 구체적으로, (예를 들어, 파싱-시간 표현 트리 엔트리(300)의 CD 필드에서 지시되는 바와 같이) 선택된 스택 엔트리의 표현 노드가 속성 자식을 가지고 있지 않으면(판정 블록 398, "아니오" 분기), 표현 프로세서(42)는, 스택들의 마지막 표현 노드가 프로세싱되었는지를 판정할 수 있다(판정 블록 400). 그렇다면(판정 블록 400, "예" 분기), 속성들을 위한 프로세싱은 종료한다. 그렇지 않으면(판정 블록 400, "아니오" 분기), 표현 프로세서(42)는 프로세싱을 위해 후속의 스택 엔트리로 진행할 수 있다(블록 410). 선택된 스택 엔트리의 표현 노드가 속성 자식을 가지고 있지 않으면(판정 블록 398, "예" 분기), 표현 프로세서(42)는 엔트리의 제 1 속성 자식을 인출한다(블록 402). 예를 들어, 엔트리의 Ptr/Attr 또는 Ptr//Attr 포인터들이 속성 자식들을 위치 지정하는데 사용될 수 있다. 자식 속성 노드가 속성과 매칭되면(블록 404, "예" 분기), 노드는 매칭 리스트로 출력된다(블록 406). 자식 속성 노드가 속성과 매칭되는지의 여부에 상관없이, 표현 프로세서(42)는, 마지막 속성 자식이 프로세싱되었는지를 판정한다(판정 블록 408). 그렇지 않다면, 후속 의 속성 자식 노드가 인출되어(블록 402), 유사한 방식으로 프로세싱된다. 자식 속성 노드가 선택된 스택 엔트리의 표현 노드에 대한 마지막 속성 자식이라면(판정 블록 408, "예" 분기), 표현 프로세서(42)는, 마지막 표현 노드가 프로세싱되었는지를 판정할 수 있고(판정 블록 400), 그에 따라 후속의 스택 엔트리로 진행하거나(블록 410) 프로세싱을 종료할 수 있다.

선택된 스택 엔트리의 PrTP 필드가 5 또는 속성 명칭과 동일하면, 속성이 선택된 스택 엔트리의 표현 노드에 대한 술어를 충족시킬 수도 있다. 따라서(판정 블록 396, "PrTP=5" 분기), 표현 프로세서(42)는 속성 일련 번호를 선택된 스택 엔트리의 PrDT 필드와 비교할 수 있다(블록 412). 속성이 PrDT 필드와 매칭되면(판정 블록 414, "예" 분기), 속성은 술어를 충족시키고 표현 프로세서(42)는 선택된 스택 엔트리의 평가 필드를 1로 설정한다(블록 416). 어떤 경우이든, 표현 프로세서(42)는 후속의 스택 엔트리로 진행할 수 있다(블록 410). 표현 프로세서(42)는, 필요하다면, 진행하기 전에, 임의의 나머지 표현 노드들이 존재하는지를 판정할 수 있다(판정 블록 400).

소정의 스택 엔트리가 0의 평가 필드 및 5가 아닌 PrTP 필드를 가질 수도 있다는 것에 주의한다. 이런 경우들에서, 표현 프로세서(42)는 후속의 스택 엔트리로 진행할 수 있다(블록 410).

이제 도 22A 및 도 22B를 참조하면, 텍스트 이벤트에 응답하여, 도 17에 도시된 파싱-시간 표현 트리(26)를 사용하는, 표현 프로세서(42)의 일 실시예의 연산을 예시하는 흐름도가 도시되어 있다. 텍스트 이벤트에 의해 식별된 텍스트 노드 가 도 22A 및 도 22B에 대한 설명에서는 좀더 간략하게 "텍스트 노드"로서 언급될 수도 있다. 일반적으로, 프로세싱은 후속 노드와의 매칭을 위해 상대적 상부-레벨 표현 노드들을 점검하는 단계 뿐만 아니라 텍스트 노드가 / 및 // 스택들(39C 및 39D)상의 표현 노드에 대한 술어를 충족시키는지의 여부 또는 이런 표현 노드의 텍스트 자식인지의 여부를 점검하는 단계도 포함할 수 있다.

텍스트 노드의 부모 노드가 루트 노드라면(판정 블록 420, "예" 분기), 추가 프로세싱은 수행되지 않는다. 한편, 텍스트 노드의 부모 노드가 루트 노드가 아니라면(판정 블록 420, "아니오" 분기), 표현 프로세서(42)는 계속된다.

표현 프로세서(42)는 텍스트 노드에 대한 매칭을 위해 상대적 상부-레벨 표현 노드들 각각을 점검할 수 있다(블록 422). 소정의 상대적 상부-레벨 표현 노드와의 매칭이 존재하면(판정 블록 424, "예" 분기), 텍스트 노드는 매칭 리스트들(39G)로 출력된다(블록 426). 매칭이 존재하는지의 여부에 상관없이, 프로세싱은, 상부-레벨 표현 노드들이 소진될 때까지(판정 블록 428, "아니오" 분기), 후속의 상대적 상부-레벨 표현 노드로써 계속될 수 있다. 일단, 상부-레벨 표현 노드들이 소진되고 나면(판정 블록 428, "예" 분기), 프로세싱은 도 22B의 참조 부호 F에서 계속된다.

도 22B의 참조 부호 F에서 계속하면, 텍스트 노드가 (/ 또는 // 스택 엔트리들 중 하나에 저장되어 있는) 앞서 매칭된 표현 노드의 자식 또는 술어와 매칭되는지를 확인하기 위해, / 및 // 스택들이 검색된다. / 및 // 스택들이 공백이면(판정 블록 430, "예" 분기), 이 텍스트 노드를 위한 매칭은 결말이 난다. 그렇지 않 으면(판정 블록 430, "아니오" 분기), 스택 엔트리가 선택된다. 엔트리의 평가 필드가 1로 설정되어 있으면, 선택된 스택 엔트리의 대응되는 표현 노드는 술어를 가지고 있지 않거나 앞서 파싱된 문서 노드에 의해 술어가 충족된 상태이다. 따라서(판정 블록 432, "Eval=1" 분기), 표현 프로세서(42)는, 텍스트 노드가 텍스트 자식들 중 어떤 것과 매칭되는지를 판정하기 위해, 선택된 스택 엔트리의 모든 텍스트 자식들을 점검할 수 있다. 좀더 구체적으로, 표현 노드가 (예를 들어, 파싱-시간 표현 트리(300)의 CD 필드에서 지시되는 바와 같이) 텍스트 자식을 가지고 있다면(판정 블록 434, "아니오" 분기), 표현 프로세서(42)는, 스택들의 마지막 표현 노드가 프로세싱되었는지를 판정할 수 있다(판정 블록 446). 그렇다면(판정 블록 446, "예" 분기), 텍스트 노드를 위한 프로세싱은 종료한다. 그렇지 않으면(판정 블록 446, "아니오" 분기), 표현 프로세서(42)는 프로세싱을 위해 후속의 스택 엔트리로 진행할 수 있다(블록 448). 표현 노드가 텍스트 자식을 가지고 있지 않다면(판정 블록 434, "예" 분기), 표현 프로세서(42)는 표현 노드의 제 1 텍스트 자식을 인출한다(블록 436). 예를 들어, 엔트리의 Ptr/ 또는 Ptr// 포인터들이 (각 자식 노드의 NT 필드와 함께) 텍스트 자식들을 위치 지정하는데 사용될 수 있다. 자식 텍스트 노드가 텍스트 노드와 매칭되면(블록 438, "예" 분기), 노드는 매칭 리스트로 출력된다(블록 440). 자식 텍스트 노드가 텍스트 노드와 매칭되는지의 여부에 상관없이, 표현 프로세서(42)는, 마지막 텍스트 자식이 프로세싱되었는지를 판정한다(판정 블록 442). 그렇지 않다면, 후속의 텍스트 자식 노드가 인출되어(블록 436), 유사한 방식으로 프로세싱된다. 자식 텍스트 노드가 선택된 스택 엔 트리의 표현 노드에 대한 마지막 텍스트 자식이라면(판정 블록 442, "예" 분기), 표현 프로세서(42)는, 마지막 표현 노드가 프로세싱되었는지를 판정할 수 있고(판정 블록 446), 그에 따라 후속의 스택 엔트리로 진행할 수 있거나(블록 448) 프로세싱을 종료할 수 있다.

선택된 스택 엔트리의 PrTP 필드가 8(노드 테스트) 또는 B(텍스트 노드 테스트)이면, 텍스트 노드는 선택된 스택 엔트리의 표현 노드에 대한 술어를 충족시킨다(판정 블록 432, "PrTP=8 또는 B" 분기). 따라서, 표현 프로세서(42)는 선택된 스택 엔트리의 평가 필드를 1로 설정한다(블록 444). 표현 프로세서(42)는 후속의 스택 엔트리로 진행할 수 있다(블록 448). 표현 프로세서(42)는, 필요하다면, 진행하기 전에, 임의의 나머지 표현 노드들이 존재하는지를 판정할 수 있다(판정 블록 446).

소정의 스택 엔트리가 0의 평가 필드 및 8 또는 B가 아닌 PrTP 필드를 가질 수도 있다는 것에 주의한다. 이런 경우, 표현 프로세서(42)는 후속의 스택 엔트리로 진행할 수 있다(블록 448).

이제 도 23A 및 도 23B를 참조하면, 코멘트 이벤트에 응답하여, 도 17에 도시된 파싱-시간 표현 트리(26)를 사용하는, 표현 프로세서(42)의 일 실시예의 연산을 예시하는 흐름도가 도시되어 있다. 코멘트 이벤트에 의해 식별되는 코멘트 노드가 도 23A 및 도 23B의 설명에서는 좀더 간략하게 "코멘트 노드"로서 언급될 수도 있다. 일반적으로, 프로세싱은 코멘트 노드와의 매칭을 위해 상대적 상부-레벨 표현 노드들을 점검하는 단계 뿐만 아니라 코멘트 노드가 / 및 // 스택들(39C 및 39D)상의 표현 노드에 대한 술어를 충족시키는지의 여부 또는 이러한 표현 노드의 코멘트 자식인지의 여부를 점검하는 단계도 포함할 수 있다.

코멘트 노드의 부모 노드가 루트 노드라면(판정 블록 450, "예" 분기), 추가 프로세싱은 수행되지 않는다. 한편, 코멘트 노드의 부모 노드가 루트 노드가 아니라면(판정 블록 450, "아니오" 분기), 표현 프로세서(42)는 계속된다.

표현 프로세서(42)는 코멘트 노드에 대한 매칭을 위해 상대적 상부-레벨 표현 노드들 각각을 점검할 수 있다(블록 452). 소정의 상대적 상부-레벨 표현 노드와의 매칭이 존재하면(판정 블록 454, "예" 분기), 코멘트 노드는 매칭 리스트들(39G)로 출력된다(블록 456). 매칭이 존재하는지의 여부에 상관없이, 프로세싱은, 상부-레벨 표현 노드들이 소진될 때까지(판정 블록 458, "아니오" 분기), 후속의 상대적 상부-레벨 표현 노드로써 계속될 수 있다. 일단, 상부-레벨 표현 노드들이 소진되고 나면(판정 블록 458, "예" 분기), 프로세싱은 도 23B의 참조 부호 G에서 계속된다.

도 23B의 참조 부호 G에서 계속하면, 코멘트 노드가 (/ 또는 // 스택 엔트리들 중 하나에 저장되어 있는) 앞서 매칭된 표현 노드의 자식 또는 술어와 매칭되는지를 확인하기 위해, / 및 // 스택들이 검색된다. / 및 // 스택들이 공백이면(판정 블록 460, "예" 분기), 이러한 코멘트 노드를 위한 매칭은 종료된다. 그렇지 않으면(판정 블록 460, "아니오" 분기), 스택 엔트리가 선택된다. 엔트리의 평가 필드가 1로 설정되어 있으면, 선택된 스택 엔트리의 대응되는 표현 노드는 술어를 가지고 있지 않거나 앞서 파싱된 문서 노드에 의해 술어가 충족된 상태이다. 따라 서(판정 블록 462, "Eval=1" 분기), 표현 프로세서(42)는, 코멘트 노드가 코멘트 자식들 중 어떤 것과 매칭되는지를 판정하기 위해, 선택된 스택 엔트리의 모든 코멘트 자식들을 점검할 수 있다. 좀더 구체적으로, 선택된 엔트리의 표현 노드가 (예를 들어, 파싱-시간 표현 트리(300)의 CD 필드에서 지시되는 바와 같이) 코멘트 자식을 가지고 있지 않다면(판정 블록 464, "아니오" 분기), 표현 프로세서(42)는, 스택들의 마지막 표현 노드가 프로세싱되었는지를 판정할 수 있다(판정 블록 476). 그렇다면(판정 블록 476, "예" 분기), 코멘트 노드를 위한 프로세싱은 결말이 난다. 그렇지 않으면(판정 블록 476, "아니오" 분기), 표현 프로세서(42)는 프로세싱을 위해 후속의 스택 엔트리로 진행할 수 있다(블록 478). 표현 노드가 코멘트 자식을 가지고 있다면(판정 블록 464, "예" 분기), 표현 프로세서(42)는 표현 노드의 제 1 코멘트 자식을 인출한다(블록 466). 예를 들어, 엔트리의 Ptr/ 또는 Ptr// 포인터들이 (각 자식 노드의 NT 필드와 함께) 코멘트 자식들을 위치 지정하는데 사용될 수 있다. 자식 코멘트 노드가 코멘트 노드와 매칭되면(블록 468, "예" 분기), 노드는 매칭 리스트로 출력된다(블록 470). 자식 코멘트 노드가 코멘트 노드와 매칭되는지의 여부에 상관없이, 표현 프로세서(42)는, 마지막 코멘트 자식이 프로세싱되었는지를 판정한다(판정 블록 472). 그렇지 않다면, 후속의 코멘트 자식 노드가 인출되어(블록 466), 유사한 방식으로 프로세싱된다. 자식 코멘트 노드가 선택된 스택 엔트리의 표현 노드에 대한 마지막 코멘트 자식이라면(판정 블록 472, "예" 분기), 표현 프로세서(42)는, 마지막 표현 노드가 프로세싱되었는지를 판정할 수 있고(판정 블록 476), 그에 따라 후속의 스택 엔트리로 진행할 수 있 거나(블록 478) 프로세싱을 종료할 수 있다.

선택된 스택 엔트리의 PrTP 필드가 8(노드 테스트) 또는 9(코멘트 노드 테스트)라면, 코멘트 노드는 선택된 스택 엔트리의 표현 노드에 대한 술어를 충족시킨다(판정 블록 462, "PrTP=8 또는 9" 분기). 따라서, 표현 프로세서(42)는 선택된 스택 엔트리의 평가 필드를 1로 설정한다(블록 474). 표현 프로세서(42)는 후속의 스택 엔트리로 진행할 수 있다(블록 478). 표현 프로세서(42)는, 필요하다면, 진행하기 전에, 임의의 나머지 표현 노드들이 존재하는지를 판정할 수 있다(판정 블록 476).

소정의 스택 엔트리가 0의 평가 필드 및 8 또는 9가 아닌 PrTP 필드를 가질 수도 있다는 것에 주의한다. 이런 경우, 표현 프로세서(42)는 후속의 스택 엔트리로 진행할 수 있다(블록 478).

이제 도 24A 및 도 24B를 참조하면, 프로세싱 명령어 이벤트에 응답하여, 도 17에 도시된 파싱-시간 표현 트리(26)를 사용하는, 표현 프로세서(42)의 일 실시예의 연산을 예시하는 흐름도가 도시되어 있다. 프로세싱 명령어 이벤트에 의해 식별된 프로세싱 명령어 노드가 도 24A 및 도 24B의 설명에서는 좀더 간략하게 "프로세싱 명령어 노드" 또는 "PI 노드"로서 언급될 수도 있다. 일반적으로, 프로세싱은 PI 노드와의 매칭을 위해 상대적 상부-레벨 표현 노드들을 점검하는 단계 뿐만 아니라 PI 노드가 / 및 // 스택들(39C 및 39D)상의 표현 노드에 대한 술어를 충족시키는지의 여부 또는 이러한 표현 노드의 PI 자식인지의 여부를 점검하는 단계도 포함할 수 있다.

PI 노드의 부모 노드가 루트 노드라면(판정 블록 480, "예" 분기), 추가 프로세싱은 수행되지 않는다. 한편, PI 노드의 부모 노드가 루트 노드가 아니라면(판정 블록 480, "아니오" 분기), 표현 프로세서(42)는 계속된다.

표현 프로세서(42)는 PI 노드에 대한 매칭을 위해 상대적 상부-레벨 표현 노드들 각각을 점검할 수 있다(블록 482). 소정의 상대적 상부-레벨 표현 노드와의 매칭이 존재한다면(판정 블록 484, "예" 분기), PI 노드는 매칭 리스트들(39G)로 출력된다(블록 486). 매칭이 존재하는지의 여부에 상관없이, 프로세싱은, 상부-레벨 표현 노드들이 소진될 때까지(판정 블록 488, "아니오" 분기), 후속의 상대적 상부-레벨 표현 노드로써 계속될 수 있다. 일단, 상부-레벨 표현 노드들이 소진되고 나면(판정 블록 488, "예" 분기), 프로세싱은 도 24B의 참조 부호 H에서 계속된다.

도 24B의 참조 부호 H에서 계속하면, PI 노드가 (/ 또는 // 스택 엔트리들 중 하나에 저장되어 있는) 앞서 매칭된 표현 노드의 자식 또는 술어와 매칭되는지를 확인하기 위해, / 및 // 스택들이 검색된다. / 및 // 스택들이 공백이면(판정 블록 490, "예" 분기), 이러한 PI 노드를 위한 매칭은 종료된다. 그렇지 않으면(판정 블록 490, "아니오" 분기), 스택 엔트리가 선택된다. 엔트리의 평가 필드가 1로 설정되어 있으면, 선택된 스택 엔트리의 대응되는 표현 노드는 술어를 가지고 있지 않거나 앞서 파싱된 문서 노드에 의해 술어가 충족된 상태이다. 따라서(판정 블록 492, "Eval=1" 분기), 표현 프로세서(42)는, PI 노드가 PI 자식들 중 어떤 것과 매칭되는지를 판정하기 위해, 선택된 스택 엔트리의 모든 PI 자식들을 점검할 수 있다. 좀더 구체적으로, 선택된 엔트리의 표현 노드가 (예를 들어, 파싱-시간 표현 트리(300)의 CD 필드에서 지시되는 바와 같이) PI 자식을 가지고 있지 않다면(판정 블록 494, "아니오" 분기), 표현 프로세서(42)는, 스택들의 마지막 표현 노드가 프로세싱되었는지를 판정할 수 있다(판정 블록 512). 그렇다면(판정 블록 512, "예" 분기), PI 노드를 위한 프로세싱은 결말이 난다. 그렇지 않으면(판정 블록 512, "아니오" 분기), 표현 프로세서(42)는 프로세싱을 위해 후속의 스택 엔트리로 진행할 수 있다(블록 514). 선택된 엔트리의 표현 노드가 PI 자식을 가지고 있다면(판정 블록 494, "예" 분기), 표현 프로세서(42)는 선택된 엔트리에서의 표현 노드의 제 1 PI 자식을 인출한다(블록 496). 예를 들어, 엔트리의 Ptr/PI 또는 Ptr//PI 포인터들이 PI 자식들을 위치 지정하는데 사용될 수 있다. 자식 PI 노드가 PI 노드와 매칭되면(블록 498, "예" 분기), 노드는 매칭 리스트로 출력된다(블록 500). 자식 PI 노드가 PI 노드와 매칭되는지의 여부에 상관없이, 표현 프로세서(42)는, 마지막 PI 자식이 프로세싱되었는지를 판정한다(판정 블록 502). 그렇지 않다면, 후속의 PI 자식 노드가 인출되어(블록 496), 유사한 방식으로 프로세싱된다. 자식 PI 노드가 선택된 스택 엔트리의 표현 노드에 대한 마지막 PI 자식이라면(판정 블록 502, "예" 분기), 표현 프로세서(42)는, 마지막 표현 노드가 프로세싱되었는지를 판정할 수 있고(판정 블록 512), 그에 따라 후속의 스택 엔트리로 진행할 수 있거나(블록 514) 프로세싱을 종료할 수 있다.

선택된 스택 엔트리의 PrTP 필드가 8(노드 테스트) 또는 A(PI 노드 테스트)이면, PI 노드는 선택된 스택 엔트리의 표현 노드에 대한 술어를 충족시킨다. 따 라서, 표현 프로세서(42)는 선택된 스택 엔트리의 평가 필드를 1로 설정한다(블록 510). 표현 프로세서(42)는 후속의 스택 엔트리로 진행할 수 있다(블록 514). 표현 프로세서(42)는, 필요하다면, 진행하기 전에, 임의의 나머지 표현 노드들이 존재하는지를 판정할 수 있다(판정 블록 512).

선택된 스택 엔트리의 PrTP 필드가 6(명칭을 갖춘 PI 노드 테스트)인 경우, PI 노드는, PI 노드의 PITarget이 PrDT 필드와 매칭되면, 술어를 충족시킨다. 표현 프로세서(42)는 PITarget을 PrDT 필드와 비교한다(블록 506). 매칭이 검출되면(판정 블록 508, "예" 분기), 표현 프로세서(42)는 선택된 엔트리의 평가 필드를 1로 설정한다(블록 510). 표현 프로세서(42)는 후속의 스택 엔트리로 진행할 수 있다(블록 514). 표현 프로세서(42)는, 필요하다면, 진행하기 전에, 임의의 나머지 표현 노드들이 존재하는지를 판정할 수 있다(판정 블록 512).

소정의 스택 엔트리가 0의 평가 필드 및 6, 8 또는 A가 아닌 PrTP 필드를 가질 수도 있다는 것에 주의한다. 이런 경우, 표현 프로세서(42)는 후속의 스택 엔트리로 진행할 수 있다(블록 514).

일부 실시예들에서는, 표현 프로세서(42)가 파이프라인될 수도 있다는 것에 주의한다. 예를 들어, 노드들의 비교들은 그러한 노드들의 인출 단계(및 술어들을 가진 노드들에 대한, 평가 필드의 점검 단계)보다 이후의 파이프라인 단계에서 발생할 수도 있다. 이런 환경들에서, / 및 // 스택 엔트리들은, 평가 필드에 대한 잠재적 변화가 파이프라인 중일 때 설정될 수 있는 진행 중 비트(in-progress bit)를 포함할 수 있다. 진행 중 비트는, 설정될 경우, 엔트리가 비지(busy) 상태라는 것을 지시할 수 있으므로, 후속 이벤트는 비교가 완결되기 전에 평가 필드를 판독할 수 없다.

상기한 여러 포인트들에서, 표현 노드는 / 스택(39C) 또는 // 스택(39D)으로 푸시되는 것으로 언급될 수 있다는 것에 주의한다. 표현 노드를 스택(39C-39D)으로 푸시하는 단계는 노드의 표현 트리 엔트리(300)(또는 표현 매칭에 사용되는 일부의 표현 트리 엔트리)를 스택으로 푸시하는 단계를 포함할 수 있다는 것에 주의한다. 필요하다면, 엔트리에 추가 정보(예를 들어, 평가 필드와 같은, 매칭들의 진행 상태를 지시하는 다양한 상태 변수들)가 포함될 수도 있다.

상기 개시가 완전히 이해되고 나면, 당업자들에게는 다양한 변경들 및 변형들이 명백할 것이다. 다음의 청구항들은 이러한 모든 변경들 및 변형들을 포함하는 것으로 해석되어야 한다.

Claims (16)

1. 장치에 있어서,

   스타일 시트에서의 표현들을 식별하도록 구성되어 있으며 상기 스타일 시트 안의 표현들을 표현하는 하나 이상의 표현 트리를 발생시키도록 구성되고, 세 개의 시간적 시기(phase) 즉, 선조 및/또는 후손 참조가 없고 술어들(predicate)이 없는 표현들을 위한 컴파일 시기, 현재 노드, 다음 노드 또는 구성 요소값(element value)을 참조하는 술어가 없는 표현들을 위한 파싱 시기 및 나머지 표현들을 위한 변환 시기로 상기 표현들을 카테고리화하도록 구성되는 스타일 시트 컴파일러; 및

   문서 및 상기 표현 트리를 수신하도록 결합되어 있으며, 상기 하나 이상의 표현 트리들로 표현되어 있는 표현들을 상기 문서와 비교하여 평가하도록 구성되고, 첫번째로 상기 컴파일 시기 표현들을 평가하고, 두 번째로 상기 파싱 시기 표현들을 평가하며, 세 번째로 상기 변환 시기 표현들을 평가하는, 세 개의 시간적 시기들에서 작동하는 문서 프로세서를 포함하고,

   하나 이상의 공통 노드들을 가진 표현들은 상기 표현 트리의 서브트리(subtree)의 자식들로서 표현되며, 상기 서브트리는 상기 공통 노드를 나타내는, 장치.
2. 제 1 항에 있어서,

   상기 문서 프로세서는 파서 및 표현 프로세서를 포함하고,

   상기 파서는 노드들을 식별하기 위해 상기 문서를 파싱하도록 구성되어 있으며, 상기 파서는 식별된 노드들의 표시들을 상기 표현 프로세서로 전달하도록 구성되어 있고, 상기 표현 프로세서는 상기 식별된 노드들을 상기 하나 이상의 표현 트리에 매칭하도록 구성되는 것인, 장치.
3. 제 2 항에 있어서, 상기 문서 프로세서는 상기 표현 프로세서에 의해 식별되는 표현을 충족시키는 매칭 노드들에 대해 각 표현에 대응되는 액션들을 수행하도록 구성되어 있는 변환 엔진을 더 포함하는, 장치.
4. 제 3 항에 있어서,

   표현이 상기 표현 프로세서가 파싱 시기 동안에 평가할 수 없는 실행-시간 술어(run-time predicate)를 포함한다면, 상기 스타일 시트 컴파일러는 상기 문서 안에서 상기 실행-시간 술어와 같은 값을 가지는 노드들을 기록하고(note), 기록된 상기 노드들을 적어도 하나의 그룹으로 형성하도록 구성되고,

   상기 표현 프로세서는 상기 문서 안의 상기 적어도 하나의 그룹의 노드들을 출력하도록 구성되는 것인, 장치.
5. 제 4 항에 있어서, 상기 변환 엔진은 상기 실행-시간 술어를 평가하고, 상기 그룹으로부터 상기 실행-시간 술어를 충족시키는 노드들을 선택하도록 구성되는 것인, 장치.
6. 제 2 항에 있어서, 상기 파서는 상기 식별된 노드들에 대한 표시들을 인라인으로 상기 표현 프로세서로 전달하도록 구성되어 있고, 상기 표현 프로세서는 선행 노드들에 의해 매칭된 하나 이상의 표현 트리 안의 하나 이상의 위치들을 보유하도록 구성되는 것인, 장치.
7. 제 6 항에 있어서, 상기 선행 노드들에 의해 매칭된 상기 하나 이상의 표현 트리의 노드들을 저장하는 복수개 스택(stack)들을 상기 표현 프로세서가 유지하도록 구성되는 것인, 장치.
8. 제 7 항에 있어서, 상기 하나 이상의 표현 트리의 노드들은 부모 및/또는 자식 참조들 및 선조 및/또는 후손 참조들을 포함하고, 상기 복수개 스택들은 상기 부모 및/또는 자식 참조들 및 상기 선조 및/또는 후손 참조들을 위한 별도의 스택들을 포함하는, 장치.
9. 프로세싱 수단 안에서 실행되는 스타일 시트 컴파일러와 문서 프로세서를 포함하는 장치에서 실행되는 방법에 있어서,

   스타일 시트에서의 표현들을 식별하도록 상기 스타일 시트 컴파일러가 상기 프로세싱 수단을 구동시키는 단계;

   상기 스타일 시트 안의 상기 표현들을 나타내는 하나 이상의 표현 트리를 발생시키도록 상기 스타일 시트 컴파일러가 상기 프로세싱 수단을 구동하는 단계;

   세 개의 시간적 시기(phase) 즉, 선조 및/또는 후손 참조가 없고 현재 노드, 뒤따르는 형제 노드 또는 구성 요소값(element value)을 참조하는 술어(predicate)가 없는 표현들을 위한 컴파일 시기, 술어가 없는 표현들을 위한 파싱 시기 및 나머지 표현들을 위한 변환 시기로 상기 표현들을 카테고리화하도록 상기 프로세싱 수단을 상기 스타일 시트 컴파일러가 구동하는 단계; 및

   상기 하나 이상의 표현 트리로 나타난 상기 표현들을 문서와 비교하여 상기 문서 프로세서가 평가하는 단계를 포함하며,

   하나 이상의 공통 노드들을 가진 표현들은 상기 표현 트리의 서브트리(subtree)의 자식들로 표현되고, 상기 서브트리는 상기 공통 노드를 나타내며,

   상기 문서 프로세서는 첫 번째로 상기 컴파일 시기 표현들을 평가하고, 두 번째로 상기 파싱 시기 표현들을 평가하며, 세 번째로 상기 변환 시기 표현들을 평가하는 세 개의 시간적 시기로 동작하는 것인, 스타일 시트 컴파일러와 문서 프로세서를 포함하는 장치에서 실행되는 방법.
10. 제 9 항에 있어서,

    노드들을 식별하기 위해 문서를 파싱하는 단계;

    식별된 노드들에 대한 표시들을 표현 프로세서로 전달하는 단계; 및

    상기 표현 프로세서 안에서 상기 식별된 노드들을 상기 하나 이상의 표현 트리에 매칭시키는 단계를 더 포함하는, 스타일 시트 컴파일러와 문서 프로세서를 포함하는 장치에서 실행되는 방법.
11. 제 10 항에 있어서, 상기 표현 프로세서에 의해 식별되는 표현을 충족시키는 매칭 노드들에 대해 각 표현에 대응되는 액션들을 수행하는 단계를 더 포함하는, 스타일 시트 컴파일러와 문서 프로세서를 포함하는 장치에서 실행되는 방법.
12. 제 11 항에 있어서,

    표현이 상기 표현 프로세서가 파싱 시기 동안에 평가할 수 없는 실행-시간 술어(run-time predicate)를 포함한다면, 상기 문서 안의 노드들의 값이 상기 실행-시간 술어가 그룹화되도록 하는 값과 동일한지 상기 스타일 시트 컴파일러가 기록하고(note), 기록된 상기 노드들을 적어도 하나의 그룹으로 형성하는 단계; 및

    상기 적어도 하나의 그룹의 노드들을 상기 표현 프로세서가 출력하는 단계를 더 포함하는, 스타일 시트 컴파일러와 문서 프로세서를 포함하는 장치에서 실행되는 방법.
13. 제 12 항에 있어서,

    상기 실행-시간 술어를 평가하는 단계; 및

    상기 그룹으로부터 상기 실행-시간 술어를 충족시키는 노드들을 선택하는 단계를 더 포함하는, 스타일 시트 컴파일러와 문서 프로세서를 포함하는 장치에서 실행되는 방법.
14. 제 10 항에 있어서, 상기 식별된 노드들은 인라인으로 상기 표현 프로세서로 전달되고,

    선행 노드들에 의해 매칭된 하나 이상의 표현 트리 안의 하나 이상의 위치들을 상기 표현 프로세서가 보유하는 단계를 더 포함하는, 스타일 시트 컴파일러와 문서 프로세서를 포함하는 장치에서 실행되는 방법.
15. 제 14 항에 있어서, 상기 위치들을 보유하는 단계는,

    상기 선행 노드들에 의해 매칭된 상기 하나 이상의 표현 트리의 노드들을 저장하는 복수개 스택(stack)들을 상기 표현 프로세서가 유지하는 단계를 포함하는, 스타일 시트 컴파일러와 문서 프로세서를 포함하는 장치에서 실행되는 방법.
16. 제 15 항에 있어서, 상기 하나 이상의 표현 트리의 노드들은 부모 및/또는 자식 참조들 및 선조 및/또는 후손 참조들을 포함하고, 상기 복수개 스택들은 상기 부모 및/또는 자식 참조들 및 상기 선조 및/또는 후손 참조들을 위한 별도의 스택들을 포함하는, 스타일 시트 컴파일러와 문서 프로세서를 포함하는 장치에서 실행되는 방법.

Images