관리 테이블

이 글은 검증을 위해 추가 인용문이 필요합니다. 신뢰할 수 있는 출처에 인용문을 추가하여 이 기사를 개선하는 데 도움을 주십시오. 조달되지 않은 자재는 제거될 수 있습니다.출처 : '관리표'– 뉴스 · 신문 · 서적 · 학자 · JSTOR (2009년 2월) (이 템플릿 메시지 삭제 방법 및 삭제 시기 확인)

이 간단한 제어 테이블은 단일 입력 변수의 값에 따라 프로그램 흐름을 지시합니다.각 테이블 엔트리는 동등성(암시)을 테스트하는 가능한 입력값과 액션 컬럼에서 실행하는 관련 서브루틴을 보유하고 있다.포인터가 지원되지 않는 경우 서브루틴의 이름을 상대 서브루틴 번호로 대체할 수 있습니다.

제어 테이블은 제어 흐름을 제어하거나 프로그램 제어에 중요한 역할을 하는 테이블입니다.제어 테이블의 구조나 내용에 대한 엄격한 규칙은 없습니다.프로세서 또는 인터프리터에 의한 "실행"을 통해 흐름을 어떤 식으로든 제어할 수 있는 능력이 한정됩니다.이러한 테이블의 설계는 테이블 구동^[1][2] 설계라고 불리기도 합니다(단, 이는 일반적으로 직접 런타임 테이블이 아닌 외부 테이블에서 자동으로 코드를 생성하는 것을 의미합니다).경우에 따라서는 제어 테이블이 유한 상태 머신 기반의 오토마타 기반 프로그래밍의 특정 구현이 될 수 있습니다.제어 테이블의 계층 레벨이 여러 개 있는 경우 UML 스테이트^[3] 머신과 동등한 방식으로 동작할 수 있습니다.

제어 테이블에는 종종 조건부 표현식 또는 함수 참조와 동등한 내용이 포함되어 있으며, 일반적으로 연관성 목록의 상대 열 위치에 의해 암시됩니다.제어 테이블은 유사한 구조 또는 프로그램 문을 반복해서 프로그래밍할 필요성을 줄여줍니다.대부분의 테이블은 2차원적인 특성을 가지고 있기 때문에 프로그램 코드의 1차원적인 특성보다 더 쉽게 보고 업데이트할 수 있습니다.

경우에 따라 제어 테이블의 내용을 유지하기 위해 비프로그래머를 할당할 수 있습니다.예를 들어 사용자가 입력한 검색어에 특정 문구가 포함되어 있는 경우 검색 사용자의 위치를 제어하는 테이블에 URL(웹 주소)을 할당할 수 있습니다.구문에 "skirt"가 포함되어 있는 경우 테이블은 사용자를 "www.shopping.example/catalogs/skirts"로 라우팅할 수 있습니다.이 페이지는 스커트 제품 카탈로그 페이지입니다.(예시의 URL은 실제로는 기능하지 않습니다).프로그래머 대신 마케팅 담당자가 이러한 테이블을 관리할 수 있습니다.

일반적인 사용법

• 입력값 변환:
  • 나중에 분기 또는 포인터 검색을 위한 색인
  • 제어 흐름을 변경하기 위한 프로그램 이름, 상대 서브루틴 번호, 프로그램 레이블 또는 프로그램 오프셋
• 상태 천이를 위한 제어 변수를 사용하여 이벤트 구동 프로그래밍에서 메인 루프 제어
• 온라인 트랜잭션 처리 응용 프로그램의 프로그램 주기 제어

고도의 사용

• 인터프리터에 의해 처리된 가상 시스템에 대한 가상 명령으로 작동

바이트 코드와 비슷하지만 보통 테이블 구조 자체에 의해 암시되는 조작을 사용합니다.

테이블 구조

테이블은 고정 길이 또는 가변 길이의 여러 치수를 가질 수 있으며 보통 컴퓨터 플랫폼 간에 이동 가능하며 알고리즘 자체가 아닌 인터프리터 변경만 필요합니다.이러한 로직은 기본적으로 테이블 구조와 콘텐츠 내에 구현됩니다.테이블의 구조는 데이터 값(또는 데이터 값의 조합)을 수행할 하나 이상의 함수에 매핑하는 멀티맵 관련 배열과 유사할 수 있습니다.

1차원 테이블

아마도 가장 간단한 실시형태에서 제어테이블은 때로는 원시데이터값을 어레이에 대한 인덱스로서 직접 또는 미리 데이터에 대한 기본적인 연산을 실행함으로써 대응하는 서브루틴 오프셋, 인덱스 또는 포인터로 직접 변환하기 위한 1차원 테이블일 수 있다.이것은 (관련 배열의 일반적인 룩업 테이블을 사용한 선형 검색이나 이진 검색 없이) 일정 시간 내에 달성할 수 있습니다.대부분의 아키텍처에서는 비교나 루프 없이 2~3개의 기계 명령으로 이를 달성할 수 있습니다.이 기술은 "삼차 해시 함수" 또는 분기 테이블에 특별히 사용되는 경우 "이중 디스패치"로 알려져 있습니다.이를 실현하려면 데이터의 가능한 모든 값의 범위가 작아야 합니다(예: 16진수 '00' ~ 'FF' 범위의 ASCII 또는 EBCDIC 문자 값).실제 범위가 이 값보다 작을 경우 어레이를 256바이트 미만으로 잘라낼 수 있습니다).

1차원 배열을 사용하여 원시 ASCII 값(A,D,M,S)을 새로운 서브루틴 인덱스(1,4,3,2)로 일정 시간 변환하기 위한 표

(이 예에서는 범위 내의 값이 '..'로 표시되어 있습니다.즉, '다음 행까지의 모든 16진수 값'을 의미합니다.처음 두 열은 배열의 일부가 아닙니다.)

오토마타 기반의 프로그래밍 및 의사 변환 트랜잭션 처리에 있어서, 다른 프로그램 상태의 수가 적은 경우, 메인 프로그램 루프의 전체 흐름을 효율적으로 지시하기 위해 "밀도 시퀀스" 제어 변수를 사용할 수 있다.

2바이트의 원시 데이터 값은 256개의 다른 출력 값만 허용하면서 모든 입력 가능성을 처리하기 위해 최소 65,536바이트의 테이블 크기가 필요합니다.단, 이 다이렉트 변환 기술은 충분한 고속 액세스메모리와 함께 휴리스틱을 사용할 수 있는 경우 매우 빠른 검증과 (상대적인) 서브루틴 포인터로 변환할 수 있습니다.

분기 테이블

분기 테이블은 직전 분기 및 인덱스된 분기에 의해 분기되었을 때 프로그램 라벨에 멀티웨이 분기를 적용하는 연속 기계 코드 분기/점프 명령의 1차원 '어레이'이다.최적화 컴파일러는 스위치 문을 실행하기 위해 생성될 수 있습니다.단, 입력 범위가 작고 밀도가 높으며 (앞의 어레이 예에서 작성한 바와 같이) 간극이 거의 없는 경우입니다[1].

매우 콤팩트하지만, 여러 개의 동등한 제품과 비교가 안 됩니다.If스테이트먼트: 브랜치오퍼코드 및 상태 코드 마스크는 브랜치오프셋과 함께 반복되므로 브랜치명령어는 여전히 용장성을 유지합니다.프로그램 라벨에 대한 오프셋만을 포함한 제어테이블은 (적어도 어셈블리 언어에서) 이 용장성을 극복하기 위해 구성될 수 있지만, 기존의 분기테이블에 비해 약간의 실행시간 오버헤드만을 필요로 한다.

다차원 테이블

일반적으로 관리 테이블은 진실 테이블 또는 인쇄된 의사결정 테이블(또는 여러 수준의 의사결정 테이블 트리)의 실행 가능한("이진수") 구현으로 간주할 수 있습니다.여기에는 하나 이상의 관련 '액션'과 함께 (종종 암시적으로) 제안이 포함됩니다.이러한 작업은 일반적으로 "인터프리터" 프로그램에 의해 호출되는 일반 또는 사용자 지정 서브루틴에 의해 수행됩니다.이 인스턴스의 인터프리터는 제어 테이블 항목을 '실행'하여 인터프리터의 기본 코드보다 더 높은 수준의 추상화를 제공하는 가상 시스템으로 효과적으로 작동합니다.

제어테이블은 언어 의존형 스위치문과 유사한 라인을 따라 구성될 수 있지만 입력값의 조합(부울 스타일 AND/OR 조건 사용) 및 잠재적으로 여러 서브루틴을 호출할 수 있는 가능성이 추가된다(단일 세트의 값 및 '브런치 투' 프로그램 라벨 대신).(어떤 경우에도 switch 스테이트먼트구조를 사용할 수 없거나 High Level Languages(HLL; 고급언어)의 구현이 혼동스러울 수 있습니다.이에 비해 제어 테이블 개념은 고유한 언어 의존성이 없지만 선택된 프로그래밍 언어의 사용 가능한 데이터 정의 기능에 따라 다르게 구현될 수 있습니다.)

표 내용

제어테이블은 프로그래밍 언어 구문 및 플랫폼 의존 컴포넌트(예를 들어 IF/THEN DO.., FOR.., DO WHILE.., SWITCH, GOTO, CALL)를 제거한 기존 프로그램의 '에센스'와 그 변수(예를 들어 입력1), 값(예를 들어 'A'), 'M'를 본질적으로 구현한다.또는 #1, #2, ..)을 클릭합니다.표 자체의 구조는 일반적으로 관련된 (기본값) 논리 연산을 의미합니다. 예를 들어, '평등을 위한 테스트', 서브루틴 및 '다음 연산을 수행하거나 기본 시퀀스를 따릅니다(다른 프로그래밍 패러다임에서 요구되는 것처럼 프로그램 문에서 명시적으로 명시되지 않음).

다차원 제어 테이블에는 최소한 값/동작 쌍이 포함되며 입력 또는 출력 데이터의 위치, 크기 및 형식, 데이터 변환(또는 기타 런타임 처리 뉘앙스)이 처리 전 또는 후에 필요한지 여부 등의 연산자 및 유형 정보가 추가로 포함될 수 있습니다(아직 fu에 함축되어 있지 않은 경우).nation 자체).테이블에는 "행"의 다른 값에 따라 실행될 일반 또는 사용자 정의된 원시 요소 또는 서브루틴에 대한 인덱스 또는 상대 또는 절대 포인터가 포함될 수도 있고 포함되지 않을 수도 있습니다.

표에 특정 입력이 지정되어 있지 않기 때문에 아래 표는 'input1'에만 적용됩니다.

구조에 의해 암시되는 조건과 행동

(7) IF =	(연주) 실행하다
가치	액션.
가치	액션.

(이러한 가치와 액션의 병렬 페어링은 이벤트 중심 프로그래밍의 구성, 즉 이벤트 감지 및 이벤트 처리와 유사하지만 이벤트 자체의 비동기적 특성은 (필요하게) 없습니다.)

제어 테이블 내에서 부호화할 수 있는 값의 다양성은 주로 사용되는 컴퓨터 언어에 따라 달라집니다.어셈블리 언어는 (액션의) 직접 실행 가능한 기계 코드 옵션을 포함한 데이터 유형의 가장 광범위한 범위를 제공합니다.일반적으로 제어 테이블에는 액션서브루틴에 대응하는 포인터와 함께 일치하는 각 입력 클래스의 값이 포함됩니다.일부 언어에서는 포인터를 (직접) 지원하지 않는다고 주장하지만, 대신 테이블 엔트리의 값에 의해 제어되는 조건부 실행을 수행하기 위해 '상대 서브루틴 번호'를 나타내는 인덱스를 지원할 수 있습니다(예를 들어 공백이 없는 최적화된 SWITCH 문(멀티웨이 브랜치)으로 사용).

각 컬럼(또는 내장된 텍스트 문서) 위에 배치된 코멘트는 의사결정 테이블을 그 본질까지 압축(부호화)한 후에도(특히 각 고유 액션을 열거한 인쇄된 의사결정 테이블이 코딩되기 전에 작성되는 경우) '인간이 읽을 수 있는' 상태로 만들 수 있습니다.gins) 테이블 항목에는 '실행 중' 또는 이후 최적화를 위한 런타임 통계를 수집하는 카운터가 선택적으로 포함될 수도 있습니다.

테이블 위치

제어 테이블은 정적 스토리지, 플랫 파일 또는 데이터베이스와 같은 보조 스토리지 또는 프로그램 초기화 시 파라미터(테이블 내에 존재할 수 있음)에 부분적으로 또는 전체적으로 동적으로 구축될 수 있습니다.최적의 효율을 위해 인터프리터가 테이블을 사용하기 시작할 때 테이블은 메모리에 상주해야 합니다.

인터프리터와 서브루틴

통역사는 고급 언어를 포함하여 적합한 프로그래밍 언어로 작성될 수 있습니다.적절히 설계된 범용 인터프리터는 잘 선택된 범용 서브루틴 세트(가장 일반적으로 발생하는 프리미티브를 처리할 수 있음)와 함께 새로운 커스텀서브루틴에 대해서만 (제어 테이블 자체를 지정하는 것에 가세해) 추가의 통상적인 코딩이 필요합니다.인터프리터는 옵션으로 완전한 애플리케이션 프로그램의 잘 정의된 일부 섹션(메인 컨트롤 루프 등)에만 적용할 수 있으며, 다른 '조건부' 섹션(프로그램 초기화, 종료 등)에는 적용할 수 없습니다.

인터프리터는 지나치게 복잡하거나 컴파일러 라이터의 고도의 지식을 가진 프로그래머에 의해 제작될 필요가 없으며, 일반적으로 효율성을 염두에 두고 설계되어 있다는 점을 제외하고는 다른 응용 프로그램과 마찬가지로 작성할 수 있습니다.주요 기능은 테이블 엔트리를 일련의 "명령"으로 "실행"하는 것입니다.제어 테이블 엔트리의 해석은 불필요하므로 가능한 한 '실행 준비'가 되도록 설계하고 적절한 컬럼에서 이미 컴파일된 인터프리터의 범용 코드로 변수를 "플러그인"할 필요가 있습니다.프로그램 명령은 이론적으로 무한 확장 가능하며, 해석자에게만 의미가 있는 테이블 내의 (아마도 임의) 값을 구성합니다.인터프리터의 제어 흐름은 보통 각 테이블 행의 순차적인 처리에 의해 이루어지지만 테이블 엔트리의 특정 액션에 의해 변경될 수 있습니다.

따라서 이러한 임의의 값은 데이터 또는 함수 포인터에 대한 직접 인덱스로 사용할 수 있는 값을 선택하여 효율성을 염두에 두고 설계할 수 있습니다.특정 플랫폼/언어에서는 분기 테이블 값을 사용하여 명령 경로 길이를 최소화하도록 특별히 설계할 수 있습니다.또한 JIT 컴파일러 등의 경우에는 직접 실행 가능한 머신 코드 "snippets"(또는 이를 가리키는 포인터)로 구성됩니다.

서브루틴은 인터프리터 자체 또는 지원되는 다른 프로그램 언어로 코딩할 수 있습니다(적절한 언어 간 '콜' 링크 메커니즘이 있는 경우).인터프리터 및/또는 서브루틴의 언어 선택은 보통 다양한 플랫폼에서 얼마나 휴대할 필요가 있는지에 따라 달라집니다.제어 테이블의 이식성을 높이기 위해 여러 버전의 인터프리터가 있을 수 있습니다.하위 제어 테이블 포인터는 인터프리터가 기존의 구조화된 프로그램 구조를 모방하여 하위 논리 레벨에 대한 조건부 '드롭'을 나타내는 이 구성을 지원할 경우 선택적으로 '액션' 컬럼의 서브루틴 포인터를 대체할 수 있다.

퍼포먼스에 관한 고려사항

언뜻 보면 제어 테이블의 사용은 프로그램의 오버헤드에 상당히 많은 것을 추가하는 것처럼 보이며, '원어민' 프로그래밍 언어문을 실행하기 전에 인터프리터 프로세스를 필요로 한다.그러나 이것이 항상 그런 것은 아니다.표에 나타난 바와 같이 실행 가능한 코딩을 논리로부터 분리(또는 '캡슐화')함으로써 보다 쉽게 그 기능을 효율적으로 수행하도록 할 수 있다.이는 스프레드시트 어플리케이션에서 가장 명백하게 발생할 수 있습니다.기본 스프레드시트 소프트웨어는 결과를 표시하기 위해 복잡한 논리 '식'을 가능한 한 효율적으로 변환합니다.

다음 예시는 추가적인 추상화 계층을 크게 보완할 뿐만 아니라 효율성이 떨어지고 유지보수가 용이하며 길이가 긴 코드를 개선할 수 있는 잠재적인 성능 향상을 설명하기 위해 부분적으로 선택되었습니다.제시된 예는 '저수준' 어셈블리 언어 및 C 언어에 대한 것이지만, 두 경우 모두 제어 테이블 접근방식을 구현하기 위해 필요한 코드 라인은 매우 적지만 ve에 비해 매우 유의미한 일정 시간 성능 개선, 반복적인 소스 코드화 감소 및 명확성을 지원할 수 있음을 알 수 있다.기존의 프로그램 언어 구조를 수정한다.이 기사에서 테이블과 멀티웨이 분기의 효율에 관한 Donald Knuth의 인용문을 참조하십시오.

관리 테이블의 예

다음 예시는 임의적이지만(단순함을 위해 단일 입력에 기초함) 목적은 제어 흐름이 일반 프로그램 문이 아닌 테이블을 사용하여 어떻게 영향을 받을 수 있는지를 보여주는 데 있습니다.이 기법은 열의 수를 늘리거나 (옵션 및/또는 연산자를 사용하여) 여러 개의 입력에 대처하도록 쉽게 확장할 수 있다는 것을 명확히 해야 한다.마찬가지로 (계층적) '링크된' 제어 테이블을 사용함으로써 구조화된 프로그래밍을 수행할 수 있습니다(선택적으로 하위 제어 테이블을 강조 표시하기 위해 들여쓰기를 사용).

"CT1"은 단순한 룩업 테이블인 제어 테이블의 예입니다.첫 번째 열은 테스트할 입력값을 나타냅니다(암묵적인 '에 의해).IF input1 = x') 및 TRUE인 경우 대응하는 두 번째 열('액션')에는 호출(또는 SWITCH 문과 유사한)로 수행할 서브루틴 주소가 포함됩니다.실제로는 리턴이 있는 멀티웨이 브랜치('다이내믹 디스패치'의 일종)입니다.마지막 엔트리는 일치하는 항목을 찾을 수 없는 기본 케이스입니다.

CT1

입력 1	포인터
A	-->추가
S	--> 추출
M	-->멀티플라이
D	-->분할
?	--> 디폴트

다른 데이터 값과 함께 데이터 구조 내의 포인터를 지원하는 프로그래밍 언어의 경우, 위의 표(CT1)를 사용하여 테이블의 일치 값에 따라 적절한 서브루틴으로 플로우를 제어할 수 있습니다(다른 것을 나타내는 컬럼이 없으면 이 단순한 경우에서는 동등하다고 가정합니다).

IBM/360(최대 16Mb 주소 범위) 또는 Z/Architecture용 어셈블리 언어 예제

이 첫 번째 예에서는 코드화를 통한 룩업을 최적화하려는 시도가 없으며 단순한 선형 검색 기술을 사용합니다. 즉, 개념을 설명하고 소스 라인을 적게 표시하기 위한 것입니다.256개의 다른 입력값을 모두 처리하려면 약 265줄의 소스 코드(주로 단일 라인 테이블엔트리)가 필요합니다만, 복수의 「비교와 분기」는 통상 약 512줄의 소스 라인(바이너리 사이즈도 약 반감해, 각 테이블엔트리는 약 8바이트가 아닌 약 4바이트가 필요합니다).특히 일련의 '즉시 비교'/분기 명령의 경우(입력 변수가 클 경우 절약 효과가 더욱 커집니다).

*표에 항목이------------통역사------------------------------------------*루크 R14,R0,=A(4,CT1,N)설정 R14=4, R15,>테이블, R0 =no.(N)TRYCLCINPUT1,0(R15)********* 표 항목에?생물학적 동등성 액션*루프*확실히, 부하 레지스터 점 값 찾았다.er 테이블 AR15, R14 * * NO, R14 (=4) BCT R0, TRY *******를 추가하여 CT1의 다음 엔트리를 가리키고 카운트가 모두 될 때까지 되돌린 후 기본 액션을 드롭합니다.테이블 내의 어느 값도 일치하지 않습니다.LA R15,4(R15)가 디폴트엔트리(테이블 엔드 너머)를 가리키고 있습니다.액션 L R15,0(R15)이 R15에 포인터를 가져옵니다.여기서 R15 포인트 BALR R14, R15 서브루틴("콜 및 리턴")을 실행합니다.END go 이 프로그램을 종료합니다* --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------v v CT1 DC C'A', AL3(ADD) 제어 테이블 시작(4바이트 입력 길이) DC C'S', AL3(SUBtract) DC C'M', AL3(MULTIPLY) DC C'D', AL3(DIVIDE) N'4-CT 번호DC C'?', AL3(DEFAULT) 디폴트엔트리– 드롭 스루 시 모든 INPUT1 DS C 입력변수를 캐치하기 위해 사용되는 서브루틴은 이 변수 * ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------여기에 T. 대신 인라인 코드일 수 있습니다. BR R14 반환 SECT 서브루틴 #2. BR R14를 빼는 명령을 추가합니다.반품 등 

위의 예에서 통역사의 성능 향상

위의 예에서 선택하기 위해, 평균 명령 경로 길이(서브루틴 코드 제외)는 '4n/2 +3'이지만, 256 바이트 변환 $테이블$을 먼저 사용하여 직접 인덱스를 생성할 경우, 여기서 n = 1 ~ 64인 경우 경로 길이가 '5'인 상수 $시간{\displaystyle }$O$($로 쉽게 줄일 수 있습니다.CT1로 이동합니다.여기서 n = 6이면 이는 3개의 순차 비교 및 분기 명령과 동일합니다.그러나 n<=64인 경우, 다중 비교를 사용하는 것보다 평균적으로 약 13배 적은 명령이 필요하다.여기서 n=1에서 256까지는 평균적으로 약 42배 적은 명령을 사용한다. 왜냐하면 이 경우 (지수에 4를 곱하기 위해) 하나의 추가 명령이 필요하기 때문이다.

향상된 인터프리터(위의 평균 예보다 최대 26배 적은 명령, n= 1 ~ 64, 다중 비교를 사용할 때보다 최대 13배 적은 명령)

64개의 다른 입력값을 처리하려면 약 85줄의 소스 코드(주로 단일 라인 테이블 엔트리)가 필요한 반면, 복수의 '비교 및 분기'는 약 128줄(두 번째 인덱스를 추출하기 위해 256바이트의 추가 테이블이 필요함에도 불구하고 바이너리의 크기는 거의 절반)이 필요합니다.

* -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------IC 바이트는 R14 IC R14,CT1X(R14)의 lo order 비트(24~31) ** 테이블 'CT1X'의 인덱스로 EBCDIC 값을 사용하여 새로운 인덱스 FOUND L15,CT1(R14) *************를 사용하여 서브루팅에 대한 포인터를 가져옵니다.BALR R14,R15 서브루틴("CALL")을 실행하여 B END가 이 프로그램을 종료합니다* ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------0) X'00의 16바이트로 이루어진 동일한 세트x00*x'BF' DC AL1 (00,04,00,16,00,00,00,00,00,00,00,00,00) ..x'C0' – X'CF의 DC AL1(00,00,00,00,00,00,00,00,00,00,00,00)..x'D0' – X'DF' DC AL1 (00,00,08,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00)..x'E0' – X'EF' DC AL1(00,00,00,00,00,00,00,00,00,00,00,00,00,00,00)..x'F0' – X'FF' * 어셈블러를 사용하여 인덱스 값을 자동으로 계산하고 값을 보다 사용자 친화적으로 만들 수 있습니다. * (예: '04'는 위의 표 CT1X의 기호 표현식 'PADD-CT1'로 대체될 수 있음) * 수정된 CT1(인덱스 = 00, 단일 차원 CT1의 기본 동작 추가)인덱스 =00 제어 테이블의 시작(4바이트 주소 상수) PADD DC A(ADD) =04 PSUB DC A(SUBtract) =08 PMUL DC A(MULTPLY) =12 PDIV DC A(DIVIDE) =16 * 나머지 코드는 처음과 동일하게 유지됩니다.넉넉한

한층 더 개선된 인터프리터(첫 번째 예에 비해 실행 명령의 최대 21배(n>=64) 및 다중 비교를 사용하는 경우보다 최대 42배)가 필요합니다.

256개의 다른 입력값을 처리하려면 약 280줄 이하의 소스 코드가 필요합니다(주로 단일 라인 테이블 엔트리). 반면, 여러 개의 '비교 및 분기'는 약 512줄(바이너리 크기는 한 번 더 반으로 줄었습니다).

* -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------IC 바이트를 R14 IC R14,CT1X(R14)의 lo 오더 비트(24~31)로 변환** 테이블 'CT1X'의 인덱스로 사용하여 새로운 인덱스 SLL R14,2 ** x 4 (추가 명령) FOUND LR15,CT***********************************************************************************BALR R14,R15 서브루틴("CALL")을 실행하여 B END가 이 프로그램을 종료합니다* ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------0) X'00'의 16바이트로 이루어진 동일한 세트x'00'* X'00 – x'BF' DC AL1 (00, 01, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00) ..x'C0' – X'CF의 DC AL1(00,00,00,00,00,00,00,00,00,00,00)..x'D0' – X'DF' DC AL1 (00,00,02,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00)..x'E0' – X'EF' DC AL1(00,00,00,00,00,00,00,00,00,00,00,00,00,00,00)..x'F0' – X'FF' * 어셈블러를 사용하여 인덱스 값을 자동으로 계산하고 값을 보다 사용자 친화적으로 만들 수 있습니다.* (예를 들어, "01"은 위의 표 CT1X의 기호식 "PADD-CT1/4"로 대체될 수 있음) * 수정된 CT1 (지금은 01, 2, 12, 04, 04에 기반함)인덱스 =00 제어 테이블의 시작(4바이트 주소 상수) PADD DC A(ADD) =01 PSUB DC A(SUBtract) =02 PMUL DC A(MULTIPLY) =03 PDIV DC A(DIVIDE) =04 * 나머지 코드는 2nd 코드와 동일하게 유지됩니다.넉넉한

C 언어의 예 C의 이 예에서는 2개의 테이블을 사용합니다.첫 번째(CT1)는 단순한 선형 검색 1차원 룩업테이블입니다.입력(x)을 대조하여 인덱스를 취득하고 두 번째 관련 테이블(CT1p)은 점프하는 라벨 주소 테이블입니다.

 정적인 컨스턴트 차  CT1[] = {  "A",   'S',        'M',        'D' };                          /* 허용 입력값 */  정적인 컨스턴트 무효 *CT1p[] = { & &더하다, & &빼다, & &곱셈, & &나누다, & &체납};           /* 라벨은 goto로 기본*/  위해서 (인트 i = 0; i < > 크기(CT1); i++)      /* ASCII 값까지의 루프 */    {한다면 (x==CT1[i]) 에 가다 *CT1p[i]; }       /*를 찾았습니다. --> 적절한 라벨 */  에 가다 *CT1p[i+1];                           /*를 찾을 수 없습니다 --> 기본 라벨 */ 

256 바이트 테이블을 사용하여 원시 ASCII 값(x)을 고밀도 순차 인덱스 값으로 직접 변환하여 CT1p에서 지점 주소를 직접 찾는 데 사용할 경우(즉, "인덱스 매핑"과 바이트 폭 배열) 이 보다 효율적일 수 있습니다.그런 다음 가능한 모든 x 값에 대해 일정한 시간 내에 실행됩니다(CT1p에 라벨 대신 기능 이름이 포함되어 있으면 점프를 동적 함수 호출로 대체하여 스위치와 같은 goto를 제거할 수 있지만 기능 하우스키핑 비용이 추가되어 성능이 저하됩니다).

 정적인 컨스턴트 무효 *CT1p[] = {& &체납, & &더하다, & &빼다, & &곱셈, & &나누다};  /* 아래의 256바이트 테이블은 값(1,2,3,4)을 해당하는 ASCII 위치(A,S,M,D)에 보관하고, 다른 모든 값은 0x00*/로 설정합니다.  정적인 컨스턴트 차 CT1x[]={              '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',              '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',              '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',              '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',              '\x00', '\x01', '\x00', '\x00', '\x04', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x03', '\x00', '\x00',              '\x00', '\x00', '\x00', '\x02', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',              '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',              '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',              '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',              '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',              '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',              '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',              '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',              '\x00', '\x00', '\x00', '\x00', '\x03', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',              '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',              '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00'};  /* 다음 코드는 입력 문자(x)의 값에 관계없이 일정한 시간 내에 실행됩니다. */  i = CT1x(x);            /* 처음에 ASCII 값을 인덱스로 사용하여 테이블 CT1x에서 올바른 서브루틴 인덱스를 추출합니다*/  에 가다 *CT1p[i];          /* 지수에 해당하는 라벨(0=기본값, 1=추가, 2=추적, ) - CT1p */ 참조 

다음 예시는 데이터 구조에서 포인터 정의를 지원하지 않지만 서브루틴으로의 인덱스 분기를 지원하는 언어에서도 동일한 효과를 얻을 수 있는 방법을 보여 줍니다(0-based) 서브루틴 포인터 배열 내에 포함되어 있습니다.테이블(CT2)은 인덱스(두 번째 열)를 포인터 배열(CT2P)로 추출하는 데 사용됩니다.포인터 배열이 지원되지 않는 경우 SWITCH 스테이트먼트 또는 동등한 명령어를 사용하여 제어 플로우를 일련의 프로그램라벨(예를 들어 case0, case1, case2, case3, case4) 중 하나로 변경할 수 있습니다.이러한 라벨은 입력을 직접 처리하거나 적절한 서브루틴(기본값, 추가, 빼기, 곱하기 또는 나누기)으로 콜을 실행합니다.처리할 수 있을 것 같아요

CT2

입력 1	서브러 번호
A	1
S	2
M	3
D	4
?	0

위의 예와 같이 테이블 룩업을 실제로 사용하지 않고도 잠재적인 ASCII 입력값(A, S, M, D 또는 미지)을 포인터 배열 인덱스로 매우 효율적으로 변환할 수 있지만, 여기서는 첫 번째 예와 일관성을 유지하기 위한 표로 제시된다.

CT2P 포인터 어레이

포인터 배열
--> 디폴트
-->추가
--> 추출
-->멀티플라이
-->분할
-->?기타

다차원 제어 테이블은 여러 입력에 대해 여러 조건을 테스트하거나 일부 일치 기준에 따라 두 개 이상의 '동작'을 수행할 수 있는 위의 예보다 '더 복잡'할 수 있는 (즉, 사용자 정의) 구성될 수 있다.'action'은 다른 하위 제어 테이블로의 포인터를 포함할 수 있습니다.아래의 간단한 예에서는 암묵적인 'OR' 조건이 추가 컬럼으로 포함되어 있습니다(소문자 입력을 처리하기 위해 이 예에서는 각 소문자에 대해 대소문자와 동일한 서브루틴 식별자를 지정하는 추가 엔트리를 갖는 것으로 간단하게 처리할 수 있었습니다).각 입력의 실제 런타임이벤트가 발생할 때 카운트하는 추가 컬럼도 포함되어 있습니다.

CT3

입력 1	교대하는	서브러 번호	세어보세요
A	a	1	0
S	s	2	0
M	m	3	0
D	d	4	0
?	?	0	0

제어 테이블 엔트리는 절차 언어의 조건문과 매우 유사하지만, 결정적으로 실제(언어 의존) 조건문(즉, 명령)이 존재하지 않는다(일반 코드는 테이블 자체가 아니라 물리적으로 테이블 엔트리를 처리하는 인터프리터에 있다).그것은 단순히 t를 구현하는 것이다.구조와 값을 통해 로직을 프로그래밍한다.)

이와 같은 테이블에서는 일련의 유사한 테이블 엔트리가 로직 전체를 정의하는 경우 테이블 엔트리 번호 또는 포인터가 보다 일반적인 프로그램에서 프로그램 카운터를 효과적으로 대체할 수 있으며 테이블 엔트리에서도 지정된 '액션'으로 리셋될 수 있다.아래 예(CT4)는 이전 테이블을 확장하여 '다음' 엔트리를 포함(및/또는 '변경 흐름'(점프) 서브루틴 포함)하여 루프를 생성하는 방법을 보여 줍니다(이 예는 실제로 이러한 제어 테이블을 구성하는 가장 효율적인 방법은 아니지만 위의 첫 번째 예에서 점진적인 '진화'를 보여줌으로써 추가 컬럼이 어떻게 표시되는지를 보여 줍니다).를 사용하여 동작을 변경할 수 있습니다).다섯 번째 열은 단일 테이블 엔트리로 둘 이상의 작업을 시작할 수 있음을 나타냅니다. 이 경우 각 엔트리의 정상 처리 후에 수행되는 작업('-' 값은 '조건 없음' 또는 '작업 없음'을 의미합니다).

구조화된 프로그래밍 또는 "Goto-less" 코드('DO WHILE' 또는 'for loop' 구조에 상당하는 구성 요소 포함)도 적절하게 설계되고 '유도된' 제어 테이블 구조를 수용할 수 있습니다.

CT4(입력1 및 프로세스를 읽기 위한 완전한 '프로그램'으로, 'E'가 발생할 때까지 반복)

입력 1	교대하는	서브러 번호	세어보세요	뛰어내리다
-	-	5	0	-
E	e	7	0	-
A	a	1	0	-
S	s	2	0	-
M	m	3	0	-
D	d	4	0	-
?	?	0	0	-
-	-	6	0	1

CT4P 포인터 어레이

포인터 배열
--> 디폴트
-->추가
--> 추출
-->멀티플라이
-->분할
-->입력 읽기 1
--> 흐름 변경
--> 종료

테이블 구동 평가

(특정 통화의 비용 결정에 관한) 전기통신 등급의 전문가 분야에서, 테이블 중심 등급 기술은 시장의 힘에 의해 규칙이 자주 변경될 수 있는 응용 프로그램에서 제어 테이블을 사용하는 것을 보여줍니다.요금을 결정하는 ^[4][5]표는 대부분의 경우 프로그래머가 아닌 사람에 의해 단시간에 변경될 수 있습니다.

알고리즘이 인터프리터에 미리 내장되어 있지 않은 경우(따라서 테이블 내에 유지된 식의 추가 런타임 해석이 필요한 경우), 이 알고리즘은 테이블 중심 등급이 아닌 "규칙 기반 등급"으로 알려져 있으며 결과적으로 훨씬 더 많은 오버헤드를 소비합니다.

스프레드시트

스프레드시트 데이터 시트는 2차원 제어 테이블로 생각할 수 있으며, 비어 있지 않은 셀은 기본 스프레드시트 프로그램(인터프리터)에 대한 데이터를 나타냅니다.공식을 포함하는 셀에는 보통 등호 기호가 붙으며 인터프리터 내의 제어 흐름을 변경하여 다른 참조 셀의 처리를 지시하는 특수한 데이터 입력 유형을 지정합니다.두 스프레드시트를 명확하게 식별하는 것은 기본 인터프리터로부터의 공식의 외부화이며, 위의 예에서는 비 프로그래머가 제어 테이블을 쉽게 식별할 수 있는 예로 "규칙 기반 평가" 예를 들었다.

프로그래밍 패러다임

제어 테이블 기법이 특정 프로그래밍 패러다임에 속한다고 말할 수 있는 경우, 가장 가까운 유추는 오토마타 기반 프로그래밍 또는 "반사적"(테이블 엔트리가 해석자의 동작을 '수정'한다고 말할 수 있기 때문에 메타프로그래밍의 한 형태)일 수 있다.그러나 인터프리터 자체와 서브루틴은 사용 가능한 패러다임 중 하나 또는 혼합을 사용하여 프로그래밍할 수 있습니다.테이블 자체는 기본적으로 컴파일할 필요도 없고 외부 소스에서 읽을 수도 있는 "raw data" 값의 집합일 수 있습니다(플랫폼에 따라 메모리 포인터를 직접 사용하여 효율성을 높인 구현은 제외).

바이트 코드/가상 머신 명령 집합과 유사

다차원 제어 테이블은 가상 머신에서 작동하는 바이트 코드와 개념적으로 유사한 점이 몇 가지 있습니다. 즉, 실제 실행을 수행하려면 플랫폼에 의존하는 "인터프리터" 프로그램이 필요하기 때문입니다(대부분은 테이블 내용에 따라 조건부로 결정됩니다).플랫폼에 의존하지 않는 공통의 중간 「명령어 세트」를 작성하는 것을 목적으로 하는 최근의 공통의 중간 언어(CIL)와 몇개의 개념적인 유사성도 있습니다(CIL과는 달리, 다른 언어의 공통 자원으로서 사용되는 것은 아닙니다).P-code는 1966년까지 거슬러 올라가는 유사하지만 초기 구현으로 간주될 수도 있습니다.

명령 가져오기

다차원 제어 테이블을 사용하여 프로그램 흐름을 결정할 때, 일반 "하드웨어" 프로그램 카운터 기능은 첫 번째(또는 다음) 테이블 엔트리에 대한 포인터 또는 인덱스를 사용하여 효과적으로 시뮬레이션됩니다.명령의 "가져오기"에는 해당 테이블 엔트리의 데이터를 디코딩하는 작업이 포함됩니다. 엔트리에 있는 데이터의 전부 또는 일부를 먼저 복사하지 않아도 됩니다.포인터를 사용할 수 있는 프로그래밍 언어에는 콘텐츠에 액세스하고 실행 후 다음 테이블 엔트리를 가리키도록 카운터를 진행하는 오버헤드가 적다는 이중 장점이 있습니다.다음 '명령' 주소 계산(즉, 테이블 엔트리)은 모든 개별 테이블 엔트리의 선택적 추가 액션으로 수행될 수 있으며, 모든 단계에서 루프 및 점프 명령이 허용됩니다.

관리 테이블 실행 모니터링

인터프리터 프로그램은 옵션에서 프로그램 카운터(및 명령 유형에 따라 다른 관련 세부 정보)를 저장하여 디버깅, 핫스팟 검출, 코드 커버리지 분석 및 퍼포먼스 분석을 위해 실제 프로그램 흐름의 전체 또는 일부를 기록할 수 있습니다(위의 예 CT3 및 CT4 참조).

이점

• 명확성 – 정보 테이블은 어디에나 존재하며, 일반인(특히 제품 가이드의 고장 진단 테이블)도 기본적으로 이해하고 있습니다.
• 휴대성 – 100% 언어에 의존하지 않는 설계(및 플랫폼에 의존하지 않는 설계(인터프리터 제외)
• 유연성 – 프리미티브 또는 서브루틴 중 하나를 투과적으로 실행하여 문제에 맞게 맞춤 설계할 수 있습니다.
• 콤팩트성 – 표는 통상적인 플랫폼/언어 구현 의존성이 없는 상태/액션 페어링을 나란히 보여줍니다.또한 많은 경우 다음과 같은 결과가 발생합니다.
  • 바이너리 파일– 명령의 중복을 줄여 크기를 줄임
  • 소스 파일– 여러 조건문을 삭제하여 크기를 줄임
  • 프로그램 로드(또는 다운로드) 속도 향상
• 유지보수성– 테이블은 유지보수에 필요한 소스 회선의 수를 줄이는 경우가 많다.다중 비교
• 참조의 인접성 – 콤팩트한 테이블 구조 결과 테이블이 캐시에 남습니다.
• 코드 재사용– 보통 "터"를 재사용할 수 있습니다.종종 정확히 동일한 기술을 사용하여 새로운 프로그래밍 작업에 쉽게 적응할 수 있으며 '유기적으로' 확장하여 실제로 테이블 정의에 의해 제어되는 시도되고 테스트된 서브루틴의 표준 라이브러리가 될 수 있습니다.
• 효율성 – 시스템 전체의 최적화가 가능합니다.인터프리터에 대한 성능 향상은 일반적으로 인터프리터를 사용하는 모든 응용 프로그램을 개선합니다(위의 'CT1'의 예 참조).
• 확장 가능 – 인터프리터를 확장하는 것만으로 새로운 '제언'을 추가할 수 있습니다.
• 통역사는 응용 프로그램처럼 쓸 수 있다.

옵션:-

• 인터프리터는 테이블 내에서 수집된 런타임 메트릭을 사용하여 자기성찰적이고 "자기 최적화"할 수 있습니다(내림차순으로 정기적으로 정렬할 수 있는 엔트리 포함 CT3 및 CT4 참조).또한 인터프리터는 런타임에 수집된 메트릭에서 동적으로 가장 효율적인 검색 기술을 선택할 수도 있습니다(어레이 크기, 값 범위, 정렬 또는 정렬되지 않음 등).
• 다이내믹 디스패치– 공통 기능을 프리로드 할 수 있으며, 메모리 사용량을 줄이기 위해 첫 번째 조작 시에만 Import할 수 있습니다.이를 위해 테이블 내 메모화를 사용할 수 있습니다.
• 인터프리터에는 디버깅, 추적 및 모니터링 기능이 내장되어 있습니다.이 기능은 테스트 또는 '라이브' 모드에 따라 자유롭게 켜거나 끌 수 있습니다.
• 제어 테이블은 (일부 사용자 입력에 따라 또는 매개 변수에서) '즉각' 구축될 수 있으며, 그런 다음 (문자 그대로 구축 코드 없이) 인터프리터에 의해 실행될 수 있습니다.

단점들

• 트레이닝 요건– 애플리케이션 프로그래머는 일반적으로 범용 솔루션 작성 훈련을 받지 않습니다.

다음은 앞에서 설명한 1차원 표가 아닌 다차원 표에서 주로 사용됩니다.

• 오버헤드 – 가상 명령어를 '검출'해야 하는 추가 수준의 간접으로 인해 일부 증가(다만, 이는 일반적으로 효율적인 직접 번역, 검색 및 조건부 테스트 기술을 충분히 활용하여 적절히 설계된 범용 인터프리터에 의해 상쇄될 수 있습니다.)
• 데이터 테이블 항목에서 비교를 위해 복잡한 식을 직접 사용할 수는 없습니다.

(단, 이러한 '증명서 값'은 서브루틴과 조건부 테이블엔트리에서 참조되는 값 대신 미리 계산할 수 있습니다).또는 서브루틴은 완전한 복잡한 조건부 테스트(무조건의 '액션'으로서)를 실행할 수 있으며, 그 결과 진실 플래그를 설정함으로써 다음 테이블 엔트리에서 테스트할 수 있다.'구조화된 프로그램 정리' 참조)

견적서

멀티웨이 브랜칭은 매우 중요한 프로그래밍 기술로, 비효율적인 if 테스트 시퀀스로 대체되는 경우가 많습니다.Peter Naur는 최근 나에게 거의 잊혀진 컴퓨터 과학의 기본 개념으로 프로그램 흐름을 제어하기 위해 테이블을 사용하는 것을 고려하고 있다고 썼다. 그러나 그는 그것이 곧 재발견될 것으로 기대하고 있다.지금까지 제가 공부한 최고의 컴파일러 중 효율성의 열쇠입니다.

--

해석적인 언어로 쓰여진 프로그램을 보는 또 다른 방법이 있다.서브루틴 콜의 연속이라고 생각할 수 있습니다.이러한 프로그램은 실제로 서브루틴 상의 긴 콜시퀀스로 확장될 수 있으며, 반대로 이러한 시퀀스는 일반적으로 쉽게 해석될 수 있는 코드화된 형식으로 패킹될 수 있습니다.해석 기법의 장점은 표현의 간결성, 기계의 독립성 및 향상된 진단 능력이다.인터프리터는 코드 자체의 해석과 적절한 루틴으로의 분기에 소요되는 시간을 무시할 수 있도록 작성되는 경우가 많다.

--

프로그램을 나타내기 위해 필요한 공간은 공통 연산 시퀀스가 간략하게 표현되는 인터프리터를 사용함으로써 종종 감소될 수 있다.전형적인 예는 복잡한 프로토콜 또는 어휘 형식을 작은 표로 인코딩하기 위해 유한 상태 기계를 사용하는 것입니다.

--

점프 테이블은 범위 테스트를 생략할 수 있다면 특히 효율적일 수 있다.예를 들어 컨트롤 값이 열거형(또는 문자)인 경우 점프 테이블이 가능한 모든 값을 처리할 수 있을 정도로 충분히 클 경우 컨트롤 값은 작은 고정 범위만 포함할 수 있으며 범위 테스트는 중복됩니다.

--

프로그램은 사람들이 읽을 수 있도록 작성되어야 하며 부수적으로만 실행할 수 있도록 작성되어야 합니다.

--

흐름도를 보여주고 테이블을 숨기면 난 계속 혼란스러울 거야표를 보여주면 보통 흐름도가 필요 없어요. 분명할 거예요.

--

「 」를 참조해 주세요.

• 오토마타 기반
• 데이터베이스 중심 아키텍처
• 데이터 기반 테스트
• 의사결정표
• 유한 상태 기계
• 키워드 기반 테스트
• 포인터(컴퓨터 프로그래밍)
• 스위치 문 – 단일 입력 변수에 따라 여러 프로그램 라벨 중 하나로 멀티웨이 분기
• 스레드 코드
• 토큰 스레드화

메모들

레퍼런스

• 의사결정표 기반 방법론
• Go to Statements by Donald Knuth 구조화 프로그래밍
• David A에 의한 정적 검색 문제 1I994로서 멀티웨이 브랜치 문을 위한 컴파일러 코드 생성.스풀러

외부 링크

• Windows PowerShell의 Switch 문은 표준 스위치 문에 대한 확장을 설명합니다(컨트롤 테이블과 유사한 기능을 제공합니다).
• "C" 언어의 제어표 예제, 포인터를 사용, 오클랜드 대학 컴퓨터 과학부 Christopher Sawtell c1993년
• DataKinetics의 Wayne Cunneyworth가 2016년 6월 10일 Wayback Machine에서 테이블 기반 설계 아카이브
• 요건에서 표, 코드 및 테스트 by George Brooke
• P. J. H. King과 R. G. Johnson, London, London, University of London, UK, R. J. H. King의 애매한 의사결정표 사용 및 컴퓨터 프로그램으로의 변환에 관한 코멘트
• P. J. H. King의 제한된 엔트리 결정 테이블에서의 모호성
• P. J. H. King의 규칙 마스크 기법에 의한 의사결정 테이블에서 컴퓨터 프로그램으로 변환
• 다중방향 분기 코드 생성의 최적화 분석 섹션 3.9, 16페이지 색인 매핑
• Nigel의 C/C++ Jones에서 펑션 포인터 어레이를 통해 테이블을 점프합니다."Arays of Pointers to Functions [2]" Embedded Systems Programming, 1999년 5월
• 2009년 12월 이 기사의 페이지 뷰 통계

• 유한 상태 기계를 사용한 모델링 소프트웨어 – 실용적인 접근법
• 일반 컴퓨터 프로그래밍 애플리케이션을 위한 유한 상태 표 1988년 1월 마크 라이닝어
• MSDN: 트리거 기반 이벤트 처리
• c2.com의 컨트롤 테이블