Control table - Knowledge (XXG)

1198:* ------------------ interpreter --------------------------------------------* LM R14,R0,=A(4,CT1,N) Set R14=4, R15 --> table, and R0 =no. of entries in table (N) TRY CLC INPUT1,0(R15) ********* Found value in table entry ? BE ACTION * loop * YES, Load register pointer to sub-routine from table AR R15,R14 * * NO, Point to next entry in CT1 by adding R14 (=4) BCT R0,TRY ********* Back until count exhausted, then drop through . default action ... none of the values in table match, do something else LA R15,4(R15) point to default entry (beyond table end) ACTION L R15,0(R15) get pointer into R15,from where R15 points BALR R14,R15 Perform the sub-routine ("CALL" and return) B END go terminate this program * ------------------ control table -----------------------------------------* * | this column of allowable EBCDIC or ASCII values is tested '=' against variable 'input1' * | | this column is the 3-byte address of the appropriate subroutine * v v 1288:* ------------------ interpreter --------------------------------------------* SR R14,R14 ********* Set R14=0 CALC IC R14,INPUT1 * calc * put EBCDIC byte into lo order bits (24–31) of R14 IC R14,CT1X(R14) * * use EBCDIC value as index on table 'CT1X' to get new index FOUND L R15,CT1(R14) ********* get pointer to subroutine using index (0,4, 8 etc.) BALR R14,R15 Perform the sub-routine ("CALL" and return or Default) B END go terminate this program * --------------- additional translate table (EBCDIC --> pointer table INDEX) 256 bytes----* CT1X DC 12AL1(00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00) 12 identical sets of 16 bytes of x'00 * representing X'00 – x'BF' DC AL1(00, 1203:

length) DC C'?',AL3(DEFAULT) default entry – used on drop through to catch all INPUT1 DS C input variable is in this variable * ------------------ sub-routines ------------------------------------------* ADD CSECT sub-routine #1 (shown as separate CSECT here but might . alternatively be in-line code) . instruction(s) to add BR R14 return SUBTRACT CSECT sub-routine #2 . instruction(s) to subtract BR R14 return . etc..

1304:,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,00) ..x'F0' – X'FF' * the assembler can be used to automatically calculate the index values and make the values more user friendly * (for e.g. '04' could be replaced with the symbolic expression 'PADD-CT1' in table CT1X above) * modified CT1 (added a default action when index = 00, single dimension, full 31 bit address) 1355:,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,00) ..x'F0' – X'FF' * the assembler can be used to automatically calculate the index values and make the values more user friendly * (for e.g. '01' could be replaced with the symbolic expression 'PADD-CT1/4' in table CT1X above) * modified CT1 (index now based on 0,1,2,3,4 not 0,4,8,12,16 to allow all 256 variations) 1047:(and based upon just a single input for simplicity), however the intention is merely to demonstrate how control flow can be effected via the use of tables instead of regular program statements. It should be clear that this technique can easily be extended to deal with multiple inputs, either by increasing the number of columns or utilizing multiple table entries (with optional and/or operator). Similarly, by using (hierarchical) 'linked' control tables, 1334:* ------------------ interpreter --------------------------------------------* SR R14,R14 ********* Set R14=0 CALC IC R14,INPUT1 * calc * put EBCDIC byte into lo order bits (24–31) of R14 IC R14,CT1X(R14) * * use EBCDIC value as index on table 'CT1X' to get new index SLL R14,2 * * 25: 3479:'OR' condition incorporated as an extra column (to handle lower case input, however in this instance, this could equally have been handled simply by having an extra entry for each of the lower case characters specifying the same subroutine identifier as the upper case characters). An extra column to count the actual run-time events for each input as they occur is also included. 4789: 992:, requiring, as it does, an interpreter process before the 'native' programming language statements are executed. This however is not always the case. By separating (or 'encapsulating') the executable coding from the logic, as expressed in the table, it can be more readily targeted to perform its function most efficiently. This may be experienced most obviously in a 3647:(This example is actually not the most efficient way to construct such a control table but, by demonstrating a gradual 'evolution' from the first examples above, shows how additional columns can be used to modify behaviour.) The fifth column demonstrates that more than one action can be initiated with a single table entry – in this case an action to be performed 714:' of a conventional program, stripped of its programming language syntax and platform dependent components (e.g. IF/THEN DO.., FOR.., DO WHILE.., SWITCH, GOTO, CALL) and 'condensed' to its variables (e.g. input1), values (e.g. 'A','S','M' and 'D'), and subroutine identities (e.g. 'Add','subtract,..' or #1, #2,..). The structure of the table itself typically 4403:

form that is readily interpreted. The advantage of interpretive techniques are the compactness of representation, the machine independence, and the increased diagnostic capability. An interpreter can often be written so that the amount of time spent in interpretation of the code itself and branching to the appropriate routine is negligible

4048:

the processing of other referenced cells – by altering the control flow within the interpreter. It is the externalization of formulae from the underlying interpreter that clearly identifies both spreadsheets, and the above cited "rule based rating" example as readily identifiable instances of the use of control tables by non programmers.

1339:--------------- additional translate table (EBCDIC --> pointer table INDEX) 256 bytes----* CT1X DC 12AL1(00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00) 12 identical sets of 16 bytes of x'00' * representing X'00 – x'BF' DC AL1(00, 916:

entries as a set of "instructions". There need be no requirement for parsing of control table entries and these should therefore be designed, as far as possible, to be 'execution ready', requiring only the "plugging in" of variables from the appropriate columns to the already compiled generic code of the interpreter. The

4402:

There is another way to look at a program written in interpretative language. It may be regarded as a series of subroutine calls, one after another. Such a program may in fact be expanded into a long sequence of calls on subroutines, and, conversely, such a sequence can usually be packed into a coded

1359:

DC A(DEFAULT) index =00 START of Control Table (4 byte address constants) PADD DC A(ADD) =01 PSUB DC A(SUBTRACT) =02 PMUL DC A(MULTIPLY) =03 PDIV DC A(DIVIDE)

1308:

DC A(DEFAULT) index =00 START of Control Table (4 byte address constants) PADD DC A(ADD) =04 PSUB DC A(SUBTRACT) =08 PMUL DC A(MULTIPLY) =12 PDIV DC A(DIVIDE)

190:

In some cases, non-programmers can be assigned to maintain the content of control tables. For example, if a user-entered search phrase contains a certain phrase, a URL (web address) can be assigned in a table that controls where the search user is taken. If the phrase contains "skirt", then the table

3302:

supported, a SWITCH statement or equivalent can be used to alter the control flow to one of a sequence of program labels (e.g.: case0, case1, case2, case3, case4) which then either process the input directly, or else perform a call (with return) to the appropriate subroutine (default, Add, Subtract,

1202:

DC C'A',AL3(ADD) START of Control Table (4 byte entry length) DC C'S',AL3(SUBTRACT) DC C'M',AL3(MULTIPLY) DC C'D',AL3(DIVIDE) N EQU (*-CT1)/4 number of valid entries in table (total length / entry

1189:

technique – purely to illustrate the concept and demonstrate fewer source lines. To handle all 256 different input values, approximately 265 lines of source code would be required (mainly single line table entries) whereas multiple 'compare and branch' would have normally required around 512 source

125:

This simple control table directs program flow according to the value of the single input variable. Each table entry holds a possible input value to be tested for equality (implied) and a relevant subroutine to perform in the action column. The name of the subroutine could be replaced by a relative

4047:

data sheet can be thought of as a two dimensional control table, with the non empty cells representing data to the underlying spreadsheet program (the interpreter). The cells containing formula are usually prefixed with an equals sign and simply designate a special type of data input that dictates

966:

The subroutines may be coded either in the same language as the interpreter itself or any other supported program language (provided that suitable inter-language 'Call' linkage mechanisms exist). The choice of language for the interpreter and/or subroutines will usually depend upon how portable it

4439:

Jump tables can be especially efficient if the range tests can be omitted. For example, if the control value is an enumerated type (or a character) then it can only contain a small fixed range of values and a range test is redundant provided the jump table is large enough to handle all possible

915:

The interpreter does not need to be unduly complex, or produced by a programmer with the advanced knowledge of a compiler writer, and can be written just as any other application program – except that it is usually designed with efficiency in mind. Its primary function is to "execute" the table

4299:

collected within the table itself (see CT3 and CT4 – with entries that could be periodically sorted by descending count). The interpreter can also optionally choose the most efficient lookup technique dynamically from metrics gathered at run-time (e.g. size of array, range of values, sorted or

3474:

Multi-dimensional control tables can be constructed (i.e. customized) that can be 'more complex' than the above examples that might test for multiple conditions on multiple inputs or perform more than one 'action', based on some matching criteria. An 'action' can include a pointer to another

855:

Comments positioned above each column (or even embedded textual documentation) can render a decision table 'human readable' even after 'condensing down' (encoding) to its essentials (and still broadly in-line with the original program specification – especially if a printed decision table,

1338:

FOUND L R15,CT1(R14) ********* get pointer to subroutine using index (0,4, 8 etc.) BALR R14,R15 Perform the sub-routine ("CALL" and return or Default) B END go terminate this program *

4362:(these 'intermediate values' can however be calculated beforehand instead within a subroutine and their values referred to in the conditional table entries. Alternatively, a subroutine can perform the complete complex conditional test (as an unconditional 'action') and, by setting a 4139:

is involved, both in accessing the contents and also advancing the counter to point to the next table entry after execution. Calculating the next 'instruction' address (i.e. table entry) can even be performed as an optional additional action of every individual table entry allowing

4034:

If the algorithms are not pre-built into the interpreter (and therefore require additional runtime interpretation of an expression held in the table), it is known as "Rule-based Rating" rather than table-driven rating (and consequently consumes significantly more overhead).

4421:

The space required to represent a program can often be decreased by the use of interpreters in which common sequences of operations are represented compactly. A typical example is the use of a finite-state machine to encode a complex protocol or lexical format into a small

4345:

caused by virtual instructions having to be 'interpreted' (this however can usually be more than offset by a well designed generic interpreter taking full advantage of efficient direct translate, search and conditional testing techniques that may not otherwise have been

4072:– since the table entries could be said to 'modify' the behaviour of the interpreter). The interpreter itself however, and the subroutines, can be programmed using any one of the available paradigms or even a mixture. The table itself can be essentially a collection of " 4384:

recently wrote me that he considers the use of tables to control program flow as a basic idea of computer science that has been nearly forgotten; but he expects it will be ripe for rediscovery any day now. It is the key to efficiency in all the best compilers I have

975:

of a control table. A subordinate control table pointer may optionally substitute for a subroutine pointer in the 'action' columns if the interpreter supports this construct, representing a conditional 'drop' to a lower logical level, mimicking a conventional

626:

and condition code mask are repeated alongside the branch offsets. Control tables containing only the offsets to the program labels can be constructed to overcome this redundancy (at least in assembly languages) and yet requiring only minor execution time

908:), would require additional conventional coding only for new custom subroutines (in addition to specifying the control table itself). The interpreter, optionally, may only apply to some well-defined sections of a complete application program (such as the 718:

the (default) logical operations involved – such as 'testing for equality', performing a subroutine and 'next operation' or following the default sequence (rather than these being explicitly stated within program statements – as required in other

1612:

for all possible values of x (If CT1p contained the names of functions instead of labels, the jump could be replaced with a dynamic function call, eliminating the switch-like goto – but decreasing performance by the additional cost of function

122: 4030:

techniques illustrate the use of control tables in applications where the rules may change frequently because of market forces. The tables that determine the charges may be changed at short notice by non-programmers in many cases.

1326:

To handle 256 different input values, approximately 280 lines of source code or less, would be required (mainly single line table entries), whereas multiple 'compare and branch' would require around 512 lines (the size of the

3638:

in more conventional programs and may be reset in an 'action', also specified in the table entry. The example below (CT4) shows how extending the earlier table, to include a 'next' entry (and/or including an 'alter flow'

1280:

To handle 64 different input values, approximately 85 lines of source code (or less) are required (mainly single line table entries) whereas multiple 'compare and branch' would require around 128 lines (the size of the

1194:

is also approximately halved, each table entry requiring only 4 bytes instead of approximately 8 bytes for a series of 'compare immediate'/branch instructions (For larger input variables, the saving is even greater).

191:

can route the user to "www.shopping.example/catalogs/skirts", which is the skirts product catalog page. (The example URL doesn't work in practice). Marketing personnel may manage such a table instead of programmers.

141:

or play a major part in program control. There are no rigid rules about the structure or content of a control table—its qualifying attribute is its ability to direct control flow in some way through "execution" by a

694:(instead of just a single set of values and 'branch to' program labels). (The switch statement construct in any case may not be available, or has confusingly differing implementations in high level languages ( 1257:

index to CT1 from the raw EBCDIC data. Where n = 6, this would then be equivalent to just 3 sequential compare & branch instructions. However, where n<=64, on average it would need approximately 13

4156:

The interpreter program can optionally save the program counter (and other relevant details depending upon instruction type) at each stage to record a full or partial trace of the actual program flow for

4076:" values that do not even need to be compiled and could be read in from an external source (except in specific, platform dependent, implementations using memory pointers directly for greater efficiency). 1603:

This can be made more efficient if a 256 byte table is used to translate the raw ASCII value (x) directly to a dense sequential index value for use in directly locating the branch address from CT1p (i.e.

4255:

code re-use – the "interpreter" is usually reusable. Frequently it can be easily adapted to new programming tasks using precisely the same technique and can grow 'organically' becoming, in effect, a

1058:. The first column represents the input value to be tested (by an implied 'IF input1 = x') and, if TRUE, the corresponding 2nd column (the 'action') contains a subroutine address to perform by a 836:. Typically a control table will contain values for each possible matching class of input together with a corresponding pointer to an action subroutine. Some languages claim not to support 154:(although this typically refers to generating code automatically from external tables rather than direct run-time tables). In some cases, control tables can be specific implementations of 4103:(CIL) in the aim of creating a common intermediate 'instruction set' that is independent of platform (but unlike CIL, no pretensions to be used as a common resource for other languages). 567:

table size of 65,536 bytes – to handle all input possibilities – whilst allowing just 256 different output values. However, this direct translation technique provides an extremely fast

4099:

program is usually required to perform the actual execution (that is largely conditionally determined by the tables content). There are also some conceptual similarities to the recent

996:

application – where the underlying spreadsheet software transparently converts complex logical 'formulae' in the most efficient manner it is able, in order to display its results.

860:

each unique action, is created before coding begins). The table entries can also optionally contain counters to collect run-time statistics for 'in-flight' or later optimization

560:

processing, if the number of distinct program states is small, a "dense sequence" control variable can be used to efficiently dictate the entire flow of the main program loop.

187:

or program statements over and over again. The two-dimensional nature of most tables makes them easier to view and update than the one-dimensional nature of program code.

3393:

input values (A,S,M,D or unknown) into a pointer array index without actually using a table lookup, but is shown here as a table for consistency with the first example.

844:

which can be used to represent a 'relative subroutine number' to perform conditional execution, controlled by the value in the table entry (e.g. for use in an optimized

4465:

Show me your flowchart and conceal your tables, and I shall continue to be mystified. Show me your tables, and I won't usually need your flowchart; it'll be obvious.

1247: 1377:

one-dimensional lookup table – to obtain an index by matching the input (x), and the second, associated table (CT1p), is a table of addresses of labels to jump to.

4226:

compactness – table usually shows condition/action pairing side-by-side (without the usual platform/language implementation dependencies), often also resulting in

4320:

control tables can be built 'on-the-fly' (according to some user input or from parameters) and then executed by the interpreter (without building code literally).

888:

time from parameters (which themselves may reside in a table). For optimum efficiency, the table should be memory resident when the interpreter begins to use it.

4719: 4577: 3634:

In tables such as these, where a series of similar table entries defines the entire logic, a table entry number or pointer may effectively take the place of a

344:

using the raw data value either directly as the index to the array, or by performing some basic arithmetic on the data beforehand. This can be achieved in

4735: 4609: 1015:, it can be seen, in both cases, that very few lines of code are required to implement the control table approach and yet can achieve very significant 4317:

The interpreter can have debugging, trace and monitor features built-in – that can then be switched on or off at will according to test or 'live' mode

3631:

in the interpreter that processes the table entries, not in the table itself – which simply embodies the program logic via its structure and values).

4747: 4741: 3298:) array of subroutine pointers. The table (CT2) is used to extract the index (from 2nd column) to the pointer array (CT2P). If pointer arrays are 408:(gaps in the range are shown as '..' for this example, meaning 'all hex values up to next row'. The first two columns are not part of the array) 1007:

upon – what otherwise might have been – less efficient, less maintainable and lengthier code. Although the examples given are for a 'low level'

4756: 738:

processing nuances) is required before or after processing (if not already implicit in the function itself). The table may or may not contain

4131:

in that table entry – without necessarily copying all or some of the data within the entry first. Programming languages that are able to use

4679: 309:

itself – the logic of which is essentially embodied within the table structure and content. The structure of the table may be similar to a

928:

of the interpreter is normally by sequential processing of each table row but may be modified by specific actions in the table entries.

3627:

but, crucially, without the actual (language dependent) conditional statements (i.e. instructions) being present (the generic code is

735: 726:

A multi-dimensional control table will normally, as a minimum, contain value/action pairs and may additionally contain operators and

4565: 108: 4427: 4380:

Multiway branching is an important programming technique which is all too often replaced by an inefficient sequence of if tests.

4170: 557: 4292: 3245:/* the following code will execute in constant time, irrespective of the value of the input character (x) */ 695: 1277:

than the above example on average, where n= 1 to 64 and up to 13 times less than would be needed using multiple comparisons).

1166:

according to matching value from the table (without a column to indicate otherwise, equality is assumed in this simple case).

4820: 4514: 4132: 4120: 3944: 3415: 1094: 917: 837: 743: 668: 341: 245: 208: 46: 42: 89: 4784: 1688:/* the 256 byte table, below, holds values (1,2,3,4), in corresponding ASCII positions (A,S,M,D), all others set to 0x00 */ 4775: 4489: 4065: 255: 61: 4825: 4527: 4100: 221: 176: 4334:

The following mainly apply to their use in multi-dimensional tables, not the one-dimensional tables discussed earlier.

604:

to a program label when branched into by an immediately preceding, and indexed branch. It is sometimes generated by an

4701: 4162: 4729: 4716: 4584: 4212:

portability – can be designed to be 100% language independent (and platform independent – except for the interpreter)

68: 4484: 4367: 4061: 1266:

less instructions – since, in this case, one additional instruction would be required (to multiply the index by 4).

553: 163: 159: 35: 4342: 4145: 4023: 3640: 904:

interpreter, together with a well chosen set of generic subroutines (able to process the most commonly occurring

655:, together with one or more associated 'actions'. These actions are usually performed by generic or custom-built 597: 333: 310: 225: 169: 4658:

Development of Automated Scoring Algorithms for Complex Performance Assessments: A Comparison of Two Approaches

4350: 1614: 1370: 1364: 952: 806: 698:). The control table concept, by comparison, has no intrinsic language dependencies, but might nevertheless be 241: 75: 612:– provided that the input range is small and dense, with few gaps (as created by the previous array example) 4246:

maintainability – tables often reduce the number of source lines needed to be maintained v. multiple compares

924:

and constitute (possibly arbitrary) values within the table that are meaningful only to the interpreter. The

316:, where a data value (or combination of data values) may be mapped to one or more functions to be performed. 4096: 1213: 944: 679: 660: 273: 147: 143: 1262:

less instructions than using multiple compares. Where n=1 to 256, on average it would use approximately 42

4711: 4509: 4338: 4266: 4136: 3658: 3654: 1048: 989: 977: 932: 628: 57: 4306:– common functions can be pre-loaded and less common functions fetched only on first encounter to reduce 1185:

No attempt is made to optimize the lookup in coding for this first example, and it uses instead a simple

4815: 4459:"Structure and Interpretation of Computer Programs", preface to the first edition, Abelson & Sussman 3669:' constructs), can also be accommodated with suitably designed and 'indented' control table structures. 960: 757:

The table illustrated below applies only to 'input1' since no specific input is specified in the table.

652: 648: 373: 365: 3281:/* goto (Switch to) the label corresponding to the index (0=default, 1=Add, 2=Subtract,.) - see CT1p */ 3266:/* extract the correct subroutine index from table CT1x using its ASCII value as an index initially */ 999:

The examples below have been chosen partly to illustrate potential performance gains that may not only

912:) and not other, 'less conditional', sections (such as program initialization, termination and so on). 4795: 4707: 162:. If there are several hierarchical levels of control table they may behave in a manner equivalent to 4704:

describes extensions to standard switch statement (providing some similar features to control tables)

4635: 4504: 4187: 4057: 3947: 3418: 3295: 968: 841: 720: 702:

differently according to the available data definition features of the chosen programming language.)

337: 324:

In perhaps its simplest implementation, a control table may sometimes be a one-dimensional table for

298: 294: 155: 134: 4753: 4560:, Humby, E., 2007,Macdonald, 1973 ... Biggerstaff, Ted J. Englewood Cliffs, NJ : Prentice-Hall 4269:– systemwide optimization possible. Any performance improvement to the interpreter usually improves 380:". For this to be feasible, the range of all possible values of the data needs to be small (e.g. an 4494: 4330:

training requirement – application programmers are not usually trained to produce generic solutions

4183: 3624: 901: 897: 810: 687: 683: 605: 369: 1285:

is also almost halved – despite the additional 256 byte table required to extract the 2nd index).

4770: 4216: 4093: 1216:(excluding the subroutine code) is '4n/2 +3', but can easily be reduced, where n = 1 to 64, to a 1051:

can be accomplished (optionally using indentation to help highlight subordinate control tables).

905: 747: 4644: 4191: 4115:

When a multi-dimensional control table is used to determine program flow, the normal "hardware"

4736:

Some comments on the use of ambiguous decision tables and their conversion to computer programs

4640: 4622: 4603: 4561: 4250: 4107:

can also be considered a similar but earlier implementation with origins as far back as 1966.

1170: 1008: 940: 936: 873: 825: 821: 361: 313: 302: 204: 3286:

The next example below illustrates how a similar effect can be achieved in languages that do

4519: 4303: 4256: 1222: 1075: 1067: 1019:

performance improvements, reduce repetitive source coding and aid clarity, as compared with

869: 845: 675: 609: 249: 180: 4688: 4674: 4454:

Programs must be written for people to read, and only incidentally for machines to execute.

82: 4760: 4723: 4523: 4296: 4202: 4116: 4089: 4069: 3635: 1347:,00,00,00,00,00,00,00,00,00,00,00) ..x'C0' – X'CF' DC AL1(00,00,00,00, 1296:,00,00,00,00,00,00,00,00,00,00,00) ..x'C0' – X'CF' DC AL1(00,00,00,00, 1071: 1032: 849: 731: 664: 601: 568: 377: 269: 184: 988:

At first sight, the use of control tables would appear to add quite a lot to a program's

4499: 4198: 4104: 1180: 1155: 644: 429: 3651:

the normal processing of each entry ('-' values mean 'no conditions' or 'no action').

4809: 4538: 4533: 4288: 4194: 4166: 4141: 3662: 1609: 1605: 1374: 1186: 1016: 401: 353: 349: 345: 3675:(a complete 'program' to read input1 and process, repeating until 'E' encountered) 1351:,00,00,00,00,00,00,00,00,00,00,00) ..x'D0' – X'DF' DC AL1(00,00, 1300:,00,00,00,00,00,00,00,00,00,00,00) ..x'D0' – X'DF' DC AL1(00,00, 730:

information such as, the location, size and format of input or output data, whether

4683: 4408: 4390: 3644: 1159: 1055: 1028: 1012: 956: 948: 925: 833: 622:

statements – the branch instructions still carry some redundancy, since the branch

594: 590: 584: 400:

Table to translate raw ASCII values (A,D,M,S) to new subroutine index (1,4,3,2) in

357: 229: 211: 138: 4689:

Compiler code generation for multiway branch statements as a static search problem

4447:

Compiler Code Generation for Multiway Branch Statements as a Static Search Problem

4276:

extensible – new 'instructions' can be added – simply by extending the interpreter

3623:

The control table entries are then much more similar to conditional statements in

1598:/* not found --> default label */ 1583:/* found --> appropriate label */ 678:

but with the added possibility of testing for combinations of input values (using

4655:

Brian E. Clauser, Melissa J. Margolis, Stephen G. Clyman, Linette P. Ross (1997)

3389:

As in above examples, it is possible to very efficiently translate the potential

805:(This side-by-side pairing of value and action has similarities to constructs in 4471: 4311: 4260: 4249:

locality of reference – compact tables structures result in tables remaining in

4235: 4229: 4124: 4044: 1328: 1282: 1217: 1191: 1059: 993: 896:

The interpreter can be written in any suitable programming language including a

857: 739: 727: 667:, that 'executes' the control table entries and thus provides a higher level of 640: 419: 389: 24: 1544:/* loop thru ASCII values */ 674:

A control table can be constructed along similar lines to a language dependent

4790:

Finite State Tables for General Computer Programming Applications January 1988

4661:

Journal of Educational Measurement, Vol. 34, No. 2 (Summer, 1997), pp. 141–161

4381: 4220: 4206: 1163: 921: 829: 809:, namely 'event-detection' and 'event-handling' but without (necessarily) the 751: 691: 656: 217: 173: 4238:

file – reduced in size through elimination of multiple conditional statements

396:

to be smaller than this, the array can be truncated to less than 256 bytes).

4363: 4158: 1044: 935:

in mind – by selecting values that can be used as direct indexes to data or

909: 877: 572: 306: 237: 884:

or may alternatively be partially or entirely built dynamically at program

179:

embedded in them, usually implied by their relative column position in the

121: 4748:

Conversion of decision tables to computer programs by rule mask techniques

4056:

If the control tables technique could be said to belong to any particular

4085: 4073: 3666: 1360:=04 * the rest of the code remains the same as the 2nd example 1158:

alongside other data values, the above table (CT1) can be used to direct

881: 329: 281: 4657: 1309:=16 * the rest of the code remains the same as first example 1176: 1020: 972: 885: 817: 711: 663:" program. The interpreter in this instance effectively functions as a 4800: 4084:

A multi-dimensional control table has some conceptual similarities to

4307: 651:

of decision tables, at several levels). They contain (often implied)

623: 385: 16:

Data structures that control the execution order of computer commands

4785:

Modelling software with finite state machines – a practical approach

284:– but usually with operations implied by the table structure itself 4766: 4366:

as its result, it can then be tested in the next table entry. See

3390: 971:. There may be several versions of the interpreter to enhance the 613: 414: 381: 372:– without any comparisons or loops. The technique is known as a " 4710:, by Christopher Sawtell c1993, Department of Computer Science, 4026:(concerned with the determining the cost of a particular call), 3294:

support indexed branching to a subroutine – contained within a (

1078:"). The last entry is the default case where no match is found. 1063: 575:, together with sufficient fast access memory, permits its use. 4738:

by P. J. H. King and R. G. Johnson, Univ. of London, London, UK

3475:

subordinate control table. The simple example below has had an

1003:

significantly for the additional tier of abstraction, but also

832:

including (for the actions), the option of directly executable

1253:, if a 256 byte translate table is first utilized to create a 1207:

improving the performance of the interpreter in above example

18: 618:

Although quite compact – compared to the multiple equivalent

4754:

A Superoptimizer Analysis of Multiway Branch Code Generation

643:

or as an executable ("binary") implementation of a printed

571:& conversion to a (relative) subroutine pointer if the 4470:"The Mythical Man-Month: Essays on Software Engineering", 4232:– reduced in size through less duplication of instructions 4636:

Program Code Based vs. Table-driven vs. Rule-Based Rating

754:

to be executed depending upon other values in the "row".

183:. Control tables reduce the need for programming similar 4223:

transparently and be custom designed to suit the problem

4127:

to it. "Fetching" the instruction involves decoding the

1054:"CT1" is an example of a control table that is a simple 453: 150:. The design of such tables is sometimes referred to as 4776:

Page view statistics for this article for December 2009

1323:

less than would be needed using multiple comparisons).

1154:

For programming languages that support pointers within

1023:

conventional program language constructs. See also the

4279:

interpreter can be written like an application program

1212:

To make a selection in the example above, the average

305:, requiring only a change to the interpreter, not the 4080:

Analogy to bytecode / virtual machine instruction set

1225: 820:

within a control table is largely dependent upon the

639:

More usually, a control table can be thought of as a

293:

The tables can have multiple dimensions, of fixed or

4708:

Control Table example in "C" language using pointers

4273:

applications using it (see examples in 'CT1' above).

1317:

21 times less executed instructions (where n>=64)

3290:support pointer definitions in data structures but 1608:" with a byte-wide array). It will then execute in 840:(directly) but nevertheless can instead support an 49:. Unsourced material may be challenged and removed. 1241: 931:These arbitrary values can thus be designed with 376:" or, when used specifically for branch tables, " 4767:Jump Tables via Function Pointer Arrays in C/C++ 4639:, Rating Matters issue n. 12, 13 November 2002 4119:function is effectively simulated with either a 943:, they can be specifically designed to minimize 4769:Jones, Nigel. "Arrays of Pointers to Functions 4463: 4452: 4437: 4419: 4400: 4378: 1319:than the first example on average and up to 42 126:subroutine number if pointers are not supported 4623:UML state machine#Hierarchically nested states 4123:to the first (or next) table entry or else an 4730:From Requirements to Tables to Code and Tests 4357:in data table entries for comparison purposes 1373:uses two tables, the first (CT1) is a simple 690:conditions) and potentially calling multiple 671:than the underlying code of the interpreter. 8: 4680:Structured Programming with go to Statements 4395:Structured Programming with go to Statements 1336:multiply index by 4 (additional instruction) 848:statement – designed with zero gaps (i.e. a 168:Control tables often have the equivalent of 761:conditions and actions implied by structure 593:is a one-dimensional 'array' of contiguous 368:, this can be accomplished in two or three 4742:Ambiguity in limited entry decision tables 4341:– some increase because of extra level of 4241:improved program load (or download) speeds 1031:, concerning tables and the efficiency of 955:compilers, consist of directly executable 710:A control table essentially embodies the ' 563:A two byte raw data value would require a 4772:" Embedded Systems Programming, May 1999. 4633:Carl Wright, Service Level Corpo. (2002) 1238: 1224: 951:values or even, in some cases such as in 631:compared to a conventional branch table. 109:Learn how and when to remove this message 4530:, depending upon a single input variable 4215:flexibility – ability to execute either 3940: 3679: 3488: 3411: 3312: 3303:Multiply or Divide,..) to deal with it. 1087: 768: 410: 120: 4550: 4702:Switch statement in Windows PowerShell 4608:: CS1 maint: archived copy as title ( 4601: 4263:, controlled by the table definitions. 388:character value which have a range of 268:Acting as virtual instructions for a 7: 4726:by Wayne Cunneyworth of DataKinetics 4173:(see examples CT3 & CT4 above). 3661:, (incorporating the equivalent of ' 392:'00' – 'FF'. If the actual range is 332:value to a corresponding subroutine 47:adding citations to reliable sources 4796:MSDN:Trigger-Based Event Processing 1275:26 times less executed instructions 200:Transformation of input values to: 4763:section 3.9, page 16 index mapping 4152:Monitoring control table execution 4135:have the dual advantage that less 1331:is also almost halved once more). 816:The variety of values that can be 254:Controlling the program cycle for 14: 4675:Decision Table Based Methodology 1493:/* labels to goto & default*/ 4314:can be employed to achieve this. 1179:(maximum 16Mb address range) or 1070:statement). It is, in effect, a 558:pseudoconversational transaction 23: 4413:The Art of Computer Programming 4060:, the closest analogy might be 1249:with a path length of '5' with 1024: 892:The interpreter and subroutines 34:needs additional citations for 4515:Pointer (computer programming) 1235: 1229: 828:provides the widest scope for 1: 4558:Programs from decision tables 4490:Database-centric architecture 1424:/* permitted input values */ 868:Control tables can reside in 256:online transaction processing 4101:Common Intermediate Language 1313:Further improved interpreter 813:nature of the event itself) 4148:instructions at any stage. 4022:In the specialist field of 3643:) subroutine) can create a 1043:The following examples are 967:needs to be across various 939:. For particular platforms/ 920:are, in theory, infinitely 404:using one-dimensional array 4842: 4485:Automata-based programming 4432:Writing Efficient Programs 4368:Structured program theorem 4062:Automata-based programming 1039:Examples of control tables 984:Performance considerations 582: 554:automata-based programming 160:automata-based programming 4691:1I994, by David A. Spuler 4024:telecommunications rating 963:" (or pointers to them). 746:to generic or customized 600:instructions to effect a 216:a program name, relative 207:, for later branching or 4759:27 February 2012 at the 4415:Volume 1, 1997, page 202 1619: 1379: 1074:with return (a form of " 945:instruction path lengths 807:Event-driven programming 742:or relative or absolute 635:Multi-dimensional tables 242:event-driven programming 4801:Control Table in c2.com 4287:the interpreter can be 1214:instruction path length 1190:lines (the size of the 659:that are called by an " 170:conditional expressions 4712:University of Auckland 4526:to one of a number of 4510:Keyword-driven testing 4476: 4462: 4451: 4436: 4418: 4399: 4353:cannot always be used 3655:Structured programming 1243: 1242:{\displaystyle O(1)\,} 1049:structured programming 900:. A suitably designed 320:One-dimensional tables 127: 4821:Compiler construction 1244: 721:programming paradigms 374:trivial hash function 124: 4722:10 June 2016 at the 4717:Table driven design 4505:Finite-state machine 4259:of tried and tested 4171:performance analysis 4058:programming paradigm 4052:Programming paradigm 3625:procedural languages 1271:Improved interpreter 1223: 918:program instructions 370:machine instructions 156:finite-state-machine 43:improve this article 4826:Compiler structures 4495:Data-driven testing 4028:table-driven rating 4018:Table-driven rating 898:high level language 606:optimizing compiler 263:More advanced usage 152:table-driven design 4524:multiway branching 4184:Information tables 4094:platform dependent 1239: 1162:to an appropriate 1066:to – similar to a 1033:multiway branching 978:structured program 303:computer platforms 164:UML state machines 128: 4792:by Mark Leininger 4445:David.A. SPULER, 4111:Instruction fetch 4011: 4010: 3992:-->Read Input1 3921: 3920: 3619: 3618: 3468: 3467: 3385: 3384: 1171:Assembly language 1150: 1149: 1035:in this article. 1009:assembly language 937:function pointers 910:main control loop 874:auxiliary storage 826:Assembly language 822:computer language 799: 798: 778:(implied) perform 550: 549: 362:associative array 314:associative array 250:state transitions 137:that control the 119: 118: 111: 93: 4833: 4750:by P. J. H. King 4744:by P. J. H. King 4732:By George Brooke 4662: 4653: 4647: 4631: 4625: 4620: 4614: 4613: 4607: 4599: 4597: 4595: 4589: 4583:. Archived from 4582: 4574: 4568: 4555: 4520:Switch statement 4474: 4460: 4449: 4434: 4416: 4397: 4310:usage. In-table 4304:dynamic dispatch 4295:" using runtime 4257:standard library 4203:fault diagnostic 3999:-->Alter flow 3941: 3680: 3659:"Goto-less" code 3489: 3412: 3313: 3282: 3279: 3276: 3273: 3270: 3267: 3264: 3261: 3258: 3255: 3252: 3249: 3246: 3243: 3240: 3237: 3234: 3231: 3228: 3225: 3222: 3219: 3216: 3213: 3210: 3207: 3204: 3201: 3198: 3195: 3192: 3189: 3186: 3183: 3180: 3177: 3174: 3171: 3168: 3165: 3162: 3159: 3156: 3153: 3150: 3147: 3144: 3141: 3138: 3135: 3132: 3129: 3126: 3123: 3120: 3117: 3114: 3111: 3108: 3105: 3102: 3099: 3096: 3093: 3090: 3087: 3084: 3081: 3078: 3075: 3072: 3069: 3066: 3063: 3060: 3057: 3054: 3051: 3048: 3045: 3042: 3039: 3036: 3033: 3030: 3027: 3024: 3021: 3018: 3015: 3012: 3009: 3006: 3003: 3000: 2997: 2994: 2991: 2988: 2985: 2982: 2979: 2976: 2973: 2970: 2967: 2964: 2961: 2958: 2955: 2952: 2949: 2946: 2943: 2940: 2937: 2934: 2931: 2928: 2925: 2922: 2919: 2916: 2913: 2910: 2907: 2904: 2901: 2898: 2895: 2892: 2889: 2886: 2883: 2880: 2877: 2874: 2871: 2868: 2865: 2862: 2859: 2856: 2853: 2850: 2847: 2844: 2841: 2838: 2835: 2832: 2829: 2826: 2823: 2820: 2817: 2814: 2811: 2808: 2805: 2802: 2799: 2796: 2793: 2790: 2787: 2784: 2781: 2778: 2775: 2772: 2769: 2766: 2763: 2760: 2757: 2754: 2751: 2748: 2745: 2742: 2739: 2736: 2733: 2730: 2727: 2724: 2721: 2718: 2715: 2712: 2709: 2706: 2703: 2700: 2697: 2694: 2691: 2688: 2685: 2682: 2679: 2676: 2673: 2670: 2667: 2664: 2661: 2658: 2655: 2652: 2649: 2646: 2643: 2640: 2637: 2634: 2631: 2628: 2625: 2622: 2619: 2616: 2613: 2610: 2607: 2604: 2601: 2598: 2595: 2592: 2589: 2586: 2583: 2580: 2577: 2574: 2571: 2568: 2565: 2562: 2559: 2556: 2553: 2550: 2547: 2544: 2541: 2538: 2535: 2532: 2529: 2526: 2523: 2520: 2517: 2514: 2511: 2508: 2505: 2502: 2499: 2496: 2493: 2490: 2487: 2484: 2481: 2478: 2475: 2472: 2469: 2466: 2463: 2460: 2457: 2454: 2451: 2448: 2445: 2442: 2439: 2436: 2433: 2430: 2427: 2424: 2421: 2418: 2415: 2412: 2409: 2406: 2403: 2400: 2397: 2394: 2391: 2388: 2385: 2382: 2379: 2376: 2373: 2370: 2367: 2364: 2361: 2358: 2355: 2352: 2349: 2346: 2343: 2340: 2337: 2334: 2331: 2328: 2325: 2322: 2319: 2316: 2313: 2310: 2307: 2304: 2301: 2298: 2295: 2292: 2289: 2286: 2283: 2280: 2277: 2274: 2271: 2268: 2265: 2262: 2259: 2256: 2253: 2250: 2247: 2244: 2241: 2238: 2235: 2232: 2229: 2226: 2223: 2220: 2217: 2214: 2211: 2208: 2205: 2202: 2199: 2196: 2193: 2190: 2187: 2184: 2181: 2178: 2175: 2172: 2169: 2166: 2163: 2160: 2157: 2154: 2151: 2148: 2145: 2142: 2139: 2136: 2133: 2130: 2127: 2124: 2121: 2118: 2115: 2112: 2109: 2106: 2103: 2100: 2097: 2094: 2091: 2088: 2085: 2082: 2079: 2076: 2073: 2070: 2067: 2064: 2061: 2058: 2055: 2052: 2049: 2046: 2043: 2040: 2037: 2034: 2031: 2028: 2025: 2022: 2019: 2016: 2013: 2010: 2007: 2004: 2001: 1998: 1995: 1992: 1989: 1986: 1983: 1980: 1977: 1974: 1971: 1968: 1965: 1962: 1959: 1956: 1953: 1950: 1947: 1944: 1941: 1938: 1935: 1932: 1929: 1926: 1923: 1920: 1917: 1914: 1911: 1908: 1905: 1902: 1899: 1896: 1893: 1890: 1887: 1884: 1881: 1878: 1875: 1872: 1869: 1866: 1863: 1860: 1857: 1854: 1851: 1848: 1845: 1842: 1839: 1836: 1833: 1830: 1827: 1824: 1821: 1818: 1815: 1812: 1809: 1806: 1803: 1800: 1797: 1794: 1791: 1788: 1785: 1782: 1779: 1776: 1773: 1770: 1767: 1764: 1761: 1758: 1755: 1752: 1749: 1746: 1743: 1740: 1737: 1734: 1731: 1728: 1725: 1722: 1719: 1716: 1713: 1710: 1707: 1704: 1701: 1698: 1695: 1692: 1689: 1686: 1683: 1680: 1677: 1674: 1671: 1668: 1665: 1662: 1659: 1656: 1653: 1650: 1647: 1644: 1641: 1638: 1635: 1632: 1629: 1626: 1623: 1599: 1596: 1593: 1590: 1587: 1584: 1581: 1578: 1575: 1572: 1569: 1566: 1563: 1560: 1557: 1554: 1551: 1548: 1545: 1542: 1539: 1536: 1533: 1530: 1527: 1524: 1521: 1518: 1515: 1512: 1509: 1506: 1503: 1500: 1497: 1494: 1491: 1488: 1485: 1482: 1479: 1476: 1473: 1470: 1467: 1464: 1461: 1458: 1455: 1452: 1449: 1446: 1443: 1440: 1437: 1434: 1431: 1428: 1425: 1422: 1419: 1416: 1413: 1410: 1407: 1404: 1401: 1398: 1395: 1392: 1389: 1386: 1383: 1369:This example in 1251:zero comparisons 1248: 1246: 1245: 1240: 1088: 1076:dynamic dispatch 769: 676:switch statement 621: 610:switch statement 411: 356:using a typical 297:and are usually 295:variable lengths 272:processed by an 246:control variable 181:association list 114: 107: 103: 100: 94: 92: 51: 27: 19: 4841: 4840: 4836: 4835: 4834: 4832: 4831: 4830: 4806: 4805: 4761:Wayback Machine 4724:Wayback Machine 4698: 4671: 4666: 4665: 4654: 4650: 4632: 4628: 4621: 4617: 4600: 4593: 4591: 4590:on 10 June 2016 4587: 4580: 4578:"Archived copy" 4576: 4575: 4571: 4556: 4552: 4547: 4539:Token threading 4481: 4475: 4469: 4461: 4458: 4450: 4444: 4435: 4426: 4417: 4407: 4398: 4389: 4377: 4327: 4179: 4154: 4117:Program Counter 4113: 4090:virtual machine 4088:operating on a 4082: 4070:metaprogramming 4054: 4041: 4020: 3636:program counter 3284: 3283: 3280: 3277: 3274: 3271: 3268: 3265: 3262: 3259: 3256: 3253: 3250: 3247: 3244: 3241: 3238: 3235: 3232: 3229: 3226: 3223: 3220: 3217: 3214: 3211: 3208: 3205: 3202: 3199: 3196: 3193: 3190: 3187: 3184: 3181: 3178: 3175: 3172: 3169: 3166: 3163: 3160: 3157: 3154: 3151: 3148: 3145: 3142: 3139: 3136: 3133: 3130: 3127: 3124: 3121: 3118: 3115: 3112: 3109: 3106: 3103: 3100: 3097: 3094: 3091: 3088: 3085: 3082: 3079: 3076: 3073: 3070: 3067: 3064: 3061: 3058: 3055: 3052: 3049: 3046: 3043: 3040: 3037: 3034: 3031: 3028: 3025: 3022: 3019: 3016: 3013: 3010: 3007: 3004: 3001: 2998: 2995: 2992: 2989: 2986: 2983: 2980: 2977: 2974: 2971: 2968: 2965: 2962: 2959: 2956: 2953: 2950: 2947: 2944: 2941: 2938: 2935: 2932: 2929: 2926: 2923: 2920: 2917: 2914: 2911: 2908: 2905: 2902: 2899: 2896: 2893: 2890: 2887: 2884: 2881: 2878: 2875: 2872: 2869: 2866: 2863: 2860: 2857: 2854: 2851: 2848: 2845: 2842: 2839: 2836: 2833: 2830: 2827: 2824: 2821: 2818: 2815: 2812: 2809: 2806: 2803: 2800: 2797: 2794: 2791: 2788: 2785: 2782: 2779: 2776: 2773: 2770: 2767: 2764: 2761: 2758: 2755: 2752: 2749: 2746: 2743: 2740: 2737: 2734: 2731: 2728: 2725: 2722: 2719: 2716: 2713: 2710: 2707: 2704: 2701: 2698: 2695: 2692: 2689: 2686: 2683: 2680: 2677: 2674: 2671: 2668: 2665: 2662: 2659: 2656: 2653: 2650: 2647: 2644: 2641: 2638: 2635: 2632: 2629: 2626: 2623: 2620: 2617: 2614: 2611: 2608: 2605: 2602: 2599: 2596: 2593: 2590: 2587: 2584: 2581: 2578: 2575: 2572: 2569: 2566: 2563: 2560: 2557: 2554: 2551: 2548: 2545: 2542: 2539: 2536: 2533: 2530: 2527: 2524: 2521: 2518: 2515: 2512: 2509: 2506: 2503: 2500: 2497: 2494: 2491: 2488: 2485: 2482: 2479: 2476: 2473: 2470: 2467: 2464: 2461: 2458: 2455: 2452: 2449: 2446: 2443: 2440: 2437: 2434: 2431: 2428: 2425: 2422: 2419: 2416: 2413: 2410: 2407: 2404: 2401: 2398: 2395: 2392: 2389: 2386: 2383: 2380: 2377: 2374: 2371: 2368: 2365: 2362: 2359: 2356: 2353: 2350: 2347: 2344: 2341: 2338: 2335: 2332: 2329: 2326: 2323: 2320: 2317: 2314: 2311: 2308: 2305: 2302: 2299: 2296: 2293: 2290: 2287: 2284: 2281: 2278: 2275: 2272: 2269: 2266: 2263: 2260: 2257: 2254: 2251: 2248: 2245: 2242: 2239: 2236: 2233: 2230: 2227: 2224: 2221: 2218: 2215: 2212: 2209: 2206: 2203: 2200: 2197: 2194: 2191: 2188: 2185: 2182: 2179: 2176: 2173: 2170: 2167: 2164: 2161: 2158: 2155: 2152: 2149: 2146: 2143: 2140: 2137: 2134: 2131: 2128: 2125: 2122: 2119: 2116: 2113: 2110: 2107: 2104: 2101: 2098: 2095: 2092: 2089: 2086: 2083: 2080: 2077: 2074: 2071: 2068: 2065: 2062: 2059: 2056: 2053: 2050: 2047: 2044: 2041: 2038: 2035: 2032: 2029: 2026: 2023: 2020: 2017: 2014: 2011: 2008: 2005: 2002: 1999: 1996: 1993: 1990: 1987: 1984: 1981: 1978: 1975: 1972: 1969: 1966: 1963: 1960: 1957: 1954: 1951: 1948: 1945: 1942: 1939: 1936: 1933: 1930: 1927: 1924: 1921: 1918: 1915: 1912: 1909: 1906: 1903: 1900: 1897: 1894: 1891: 1888: 1885: 1882: 1879: 1876: 1873: 1870: 1867: 1864: 1861: 1858: 1855: 1852: 1849: 1846: 1843: 1840: 1837: 1834: 1831: 1828: 1825: 1822: 1819: 1816: 1813: 1810: 1807: 1804: 1801: 1798: 1795: 1792: 1789: 1786: 1783: 1780: 1777: 1774: 1771: 1768: 1765: 1762: 1759: 1756: 1753: 1750: 1747: 1744: 1741: 1738: 1735: 1732: 1729: 1726: 1723: 1720: 1717: 1714: 1711: 1708: 1705: 1702: 1699: 1696: 1693: 1690: 1687: 1684: 1681: 1678: 1675: 1672: 1669: 1666: 1663: 1660: 1657: 1654: 1651: 1648: 1645: 1642: 1639: 1636: 1633: 1630: 1627: 1624: 1621: 1601: 1600: 1597: 1594: 1591: 1588: 1585: 1582: 1579: 1576: 1573: 1570: 1567: 1564: 1561: 1558: 1555: 1552: 1549: 1546: 1543: 1540: 1537: 1534: 1531: 1528: 1525: 1522: 1519: 1516: 1513: 1510: 1507: 1504: 1501: 1498: 1495: 1492: 1489: 1486: 1483: 1480: 1477: 1474: 1471: 1468: 1465: 1462: 1459: 1456: 1453: 1450: 1447: 1444: 1441: 1438: 1435: 1432: 1429: 1426: 1423: 1420: 1417: 1414: 1411: 1408: 1405: 1402: 1399: 1396: 1393: 1390: 1387: 1384: 1381: 1361: 1310: 1221: 1220: 1204: 1156:data structures 1126:-->Multiply 1116:-->Subtract 1072:multiway branch 1041: 986: 894: 866: 850:multiway branch 732:data conversion 708: 665:virtual machine 637: 619: 602:multiway branch 587: 581: 378:double dispatch 322: 291: 289:Table structure 270:virtual machine 265: 197: 115: 104: 98: 95: 58:"Control table" 52: 50: 40: 28: 17: 12: 11: 5: 4839: 4837: 4829: 4828: 4823: 4818: 4808: 4807: 4804: 4803: 4798: 4793: 4787: 4779: 4778: 4773: 4764: 4751: 4745: 4739: 4733: 4727: 4714: 4705: 4697: 4696:External links 4694: 4693: 4692: 4686: 4677: 4670: 4667: 4664: 4663: 4648: 4626: 4615: 4569: 4549: 4548: 4546: 4543: 4542: 4541: 4536: 4531: 4528:program labels 4517: 4512: 4507: 4502: 4500:Decision table 4497: 4492: 4487: 4480: 4477: 4467: 4456: 4442: 4424: 4405: 4387: 4376: 4373: 4372: 4371: 4359: 4358: 4347: 4332: 4331: 4326: 4323: 4322: 4321: 4318: 4315: 4301: 4281: 4280: 4277: 4274: 4264: 4253: 4247: 4244: 4243: 4242: 4239: 4233: 4224: 4213: 4210: 4207:product guides 4199:general public 4178: 4175: 4153: 4150: 4112: 4109: 4081: 4078: 4053: 4050: 4040: 4037: 4019: 4016: 4015: 4014: 4013: 4012: 4009: 4008: 4002: 4001: 3995: 3994: 3988: 3987: 3981: 3980: 3978:-->Multiply 3974: 3973: 3971:-->Subtract 3967: 3966: 3960: 3959: 3953: 3952: 3950: 3935: 3934: 3933: 3932: 3923: 3922: 3919: 3918: 3913: 3908: 3903: 3898: 3892: 3891: 3886: 3881: 3876: 3871: 3865: 3864: 3859: 3854: 3849: 3844: 3838: 3837: 3832: 3827: 3822: 3817: 3811: 3810: 3805: 3800: 3795: 3790: 3784: 3783: 3778: 3773: 3768: 3763: 3757: 3756: 3751: 3746: 3741: 3736: 3730: 3729: 3724: 3719: 3714: 3709: 3703: 3702: 3697: 3692: 3687: 3684: 3621: 3620: 3617: 3616: 3611: 3606: 3601: 3595: 3594: 3589: 3584: 3579: 3573: 3572: 3567: 3562: 3557: 3551: 3550: 3545: 3540: 3535: 3529: 3528: 3523: 3518: 3513: 3507: 3506: 3501: 3496: 3493: 3472: 3471: 3470: 3469: 3466: 3465: 3459: 3458: 3452: 3451: 3449:-->Multiply 3445: 3444: 3442:-->Subtract 3438: 3437: 3431: 3430: 3424: 3423: 3421: 3406: 3405: 3404: 3403: 3387: 3386: 3383: 3382: 3377: 3371: 3370: 3365: 3359: 3358: 3353: 3347: 3346: 3341: 3335: 3334: 3329: 3323: 3322: 3317: 3239:'\x00' 3233:'\x00' 3227:'\x00' 3221:'\x00' 3215:'\x00' 3209:'\x00' 3203:'\x00' 3197:'\x00' 3191:'\x00' 3185:'\x00' 3179:'\x00' 3173:'\x00' 3167:'\x00' 3161:'\x00' 3155:'\x00' 3149:'\x00' 3143:'\x00' 3137:'\x00' 3131:'\x00' 3125:'\x00' 3119:'\x00' 3113:'\x00' 3107:'\x00' 3101:'\x00' 3095:'\x00' 3089:'\x00' 3083:'\x00' 3077:'\x00' 3071:'\x00' 3065:'\x00' 3059:'\x00' 3053:'\x00' 3047:'\x00' 3041:'\x00' 3035:'\x00' 3029:'\x00' 3023:'\x00' 3017:'\x00' 3011:'\x00' 3005:'\x00' 2999:'\x00' 2993:'\x00' 2987:'\x00' 2981:'\x03' 2975:'\x00' 2969:'\x00' 2963:'\x00' 2957:'\x00' 2951:'\x00' 2945:'\x00' 2939:'\x00' 2933:'\x00' 2927:'\x00' 2921:'\x00' 2915:'\x00' 2909:'\x00' 2903:'\x00' 2897:'\x00' 2891:'\x00' 2885:'\x00' 2879:'\x00' 2873:'\x00' 2867:'\x00' 2861:'\x00' 2855:'\x00' 2849:'\x00' 2843:'\x00' 2837:'\x00' 2831:'\x00' 2825:'\x00' 2819:'\x00' 2813:'\x00' 2807:'\x00' 2801:'\x00' 2795:'\x00' 2789:'\x00' 2783:'\x00' 2777:'\x00' 2771:'\x00' 2765:'\x00' 2759:'\x00' 2753:'\x00' 2747:'\x00' 2741:'\x00' 2735:'\x00' 2729:'\x00' 2723:'\x00' 2717:'\x00' 2711:'\x00' 2705:'\x00' 2699:'\x00' 2693:'\x00' 2687:'\x00' 2681:'\x00' 2675:'\x00' 2669:'\x00' 2663:'\x00' 2657:'\x00' 2651:'\x00' 2645:'\x00' 2639:'\x00' 2633:'\x00' 2627:'\x00' 2621:'\x00' 2615:'\x00' 2609:'\x00' 2603:'\x00' 2597:'\x00' 2591:'\x00' 2585:'\x00' 2579:'\x00' 2573:'\x00' 2567:'\x00' 2561:'\x00' 2555:'\x00' 2549:'\x00' 2543:'\x00' 2537:'\x00' 2531:'\x00' 2525:'\x00' 2519:'\x00' 2513:'\x00' 2507:'\x00' 2501:'\x00' 2495:'\x00' 2489:'\x00' 2483:'\x00' 2477:'\x00' 2471:'\x00' 2465:'\x00' 2459:'\x00' 2453:'\x00' 2447:'\x00' 2441:'\x00' 2435:'\x00' 2429:'\x00' 2423:'\x00' 2417:'\x00' 2411:'\x00' 2405:'\x00' 2399:'\x00' 2393:'\x00' 2387:'\x00' 2381:'\x00' 2375:'\x00' 2369:'\x00' 2363:'\x00' 2357:'\x00' 2351:'\x00' 2345:'\x00' 2339:'\x00' 2333:'\x00' 2327:'\x00' 2321:'\x00' 2315:'\x00' 2309:'\x00' 2303:'\x00' 2297:'\x00' 2291:'\x00' 2285:'\x00' 2279:'\x00' 2273:'\x00' 2267:'\x00' 2261:'\x00' 2255:'\x00' 2249:'\x00' 2243:'\x00' 2237:'\x00' 2231:'\x00' 2225:'\x00' 2219:'\x00' 2213:'\x00' 2207:'\x02' 2201:'\x00' 2195:'\x00' 2189:'\x00' 2183:'\x00' 2177:'\x00' 2171:'\x03' 2165:'\x00' 2159:'\x00' 2153:'\x00' 2147:'\x00' 2141:'\x00' 2135:'\x00' 2129:'\x00' 2123:'\x00' 2117:'\x04' 2111:'\x00' 2105:'\x00' 2099:'\x01' 2093:'\x00' 2087:'\x00' 2081:'\x00' 2075:'\x00' 2069:'\x00' 2063:'\x00' 2057:'\x00' 2051:'\x00' 2045:'\x00' 2039:'\x00' 2033:'\x00' 2027:'\x00' 2021:'\x00' 2015:'\x00' 2009:'\x00' 2003:'\x00' 1997:'\x00' 1991:'\x00' 1985:'\x00' 1979:'\x00' 1973:'\x00' 1967:'\x00' 1961:'\x00' 1955:'\x00' 1949:'\x00' 1943:'\x00' 1937:'\x00' 1931:'\x00' 1925:'\x00' 1919:'\x00' 1913:'\x00' 1907:'\x00' 1901:'\x00' 1895:'\x00' 1889:'\x00' 1883:'\x00' 1877:'\x00' 1871:'\x00' 1865:'\x00' 1859:'\x00' 1853:'\x00' 1847:'\x00' 1841:'\x00' 1835:'\x00' 1829:'\x00' 1823:'\x00' 1817:'\x00' 1811:'\x00' 1805:'\x00' 1799:'\x00' 1793:'\x00' 1787:'\x00' 1781:'\x00' 1775:'\x00' 1769:'\x00' 1763:'\x00' 1757:'\x00' 1751:'\x00' 1745:'\x00' 1739:'\x00' 1733:'\x00' 1727:'\x00' 1721:'\x00' 1715:'\x00' 1709:'\x00' 1620: 1380: 1333: 1287: 1268: 1267: 1237: 1234: 1231: 1228: 1197: 1181:Z/Architecture 1152: 1151: 1148: 1147: 1146:-->Default 1144: 1138: 1137: 1134: 1128: 1127: 1124: 1118: 1117: 1114: 1108: 1107: 1104: 1098: 1097: 1092: 1040: 1037: 985: 982: 893: 890: 886:initialization 865: 864:Table location 862: 803: 802: 801: 800: 797: 796: 793: 789: 788: 785: 781: 780: 775: 773:(implied) IF = 707: 704: 645:decision table 636: 633: 583:Main article: 580: 577: 548: 547: 542: 539: 535: 534: 531: 528: 524: 523: 518: 515: 511: 510: 507: 504: 500: 499: 494: 491: 487: 486: 483: 480: 476: 475: 470: 467: 463: 462: 459: 456: 450: 449: 446: 443: 439: 438: 435: 432: 426: 425: 422: 417: 328:translating a 321: 318: 290: 287: 286: 285: 277: 276: 264: 261: 260: 259: 252: 236:Controlling a 234: 233: 232: 214: 196: 193: 131:Control tables 117: 116: 31: 29: 22: 15: 13: 10: 9: 6: 4: 3: 2: 4838: 4827: 4824: 4822: 4819: 4817: 4814: 4813: 4811: 4802: 4799: 4797: 4794: 4791: 4788: 4786: 4783: 4782: 4781: 4777: 4774: 4771: 4768: 4765: 4762: 4758: 4755: 4752: 4749: 4746: 4743: 4740: 4737: 4734: 4731: 4728: 4725: 4721: 4718: 4715: 4713: 4709: 4706: 4703: 4700: 4699: 4695: 4690: 4687: 4685: 4681: 4678: 4676: 4673: 4672: 4668: 4660: 4659: 4652: 4649: 4646: 4642: 4638: 4637: 4630: 4627: 4624: 4619: 4616: 4611: 4605: 4586: 4579: 4573: 4570: 4567: 4566:0-444-19569-6 4563: 4559: 4554: 4551: 4544: 4540: 4537: 4535: 4534:Threaded code 4532: 4529: 4525: 4521: 4518: 4516: 4513: 4511: 4508: 4506: 4503: 4501: 4498: 4496: 4493: 4491: 4488: 4486: 4483: 4482: 4478: 4473: 4466: 4455: 4448: 4441: 4433: 4429: 4423: 4414: 4410: 4404: 4396: 4392: 4386: 4383: 4374: 4369: 4365: 4361: 4360: 4356: 4352: 4348: 4344: 4340: 4337: 4336: 4335: 4329: 4328: 4325:Disadvantages 4324: 4319: 4316: 4313: 4309: 4305: 4302: 4298: 4294: 4290: 4289:introspective 4286: 4285: 4284: 4283:Optionally:- 4278: 4275: 4272: 4268: 4265: 4262: 4258: 4254: 4252: 4248: 4245: 4240: 4237: 4234: 4231: 4228: 4227: 4225: 4222: 4218: 4214: 4211: 4208: 4204: 4200: 4196: 4193: 4189: 4185: 4181: 4180: 4176: 4174: 4172: 4169:analysis and 4168: 4167:code coverage 4164: 4160: 4151: 4149: 4147: 4143: 4138: 4134: 4130: 4126: 4122: 4118: 4110: 4108: 4106: 4102: 4098: 4097:"interpreter" 4095: 4091: 4087: 4079: 4077: 4075: 4071: 4067: 4063: 4059: 4051: 4049: 4046: 4038: 4036: 4032: 4029: 4025: 4017: 4007: 4004: 4003: 4000: 3997: 3996: 3993: 3990: 3989: 3986: 3983: 3982: 3979: 3976: 3975: 3972: 3969: 3968: 3965: 3962: 3961: 3958: 3957:-->Default 3955: 3954: 3951: 3949: 3946: 3943: 3942: 3939: 3938: 3937: 3936: 3931:pointer array 3930: 3927: 3926: 3925: 3924: 3917: 3914: 3912: 3909: 3907: 3904: 3902: 3899: 3897: 3894: 3893: 3890: 3887: 3885: 3882: 3880: 3877: 3875: 3872: 3870: 3867: 3866: 3863: 3860: 3858: 3855: 3853: 3850: 3848: 3845: 3843: 3840: 3839: 3836: 3833: 3831: 3828: 3826: 3823: 3821: 3818: 3816: 3813: 3812: 3809: 3806: 3804: 3801: 3799: 3796: 3794: 3791: 3789: 3786: 3785: 3782: 3779: 3777: 3774: 3772: 3769: 3767: 3764: 3762: 3759: 3758: 3755: 3752: 3750: 3747: 3745: 3742: 3740: 3737: 3735: 3732: 3731: 3728: 3725: 3723: 3720: 3718: 3715: 3713: 3710: 3708: 3705: 3704: 3701: 3698: 3696: 3693: 3691: 3688: 3685: 3682: 3681: 3678: 3677: 3676: 3674: 3670: 3668: 3664: 3660: 3656: 3652: 3650: 3646: 3642: 3637: 3632: 3630: 3626: 3615: 3612: 3610: 3607: 3605: 3602: 3600: 3597: 3596: 3593: 3590: 3588: 3585: 3583: 3580: 3578: 3575: 3574: 3571: 3568: 3566: 3563: 3561: 3558: 3556: 3553: 3552: 3549: 3546: 3544: 3541: 3539: 3536: 3534: 3531: 3530: 3527: 3524: 3522: 3519: 3517: 3514: 3512: 3509: 3508: 3505: 3502: 3500: 3497: 3494: 3491: 3490: 3487: 3486: 3485: 3484: 3480: 3478: 3464: 3461: 3460: 3457: 3454: 3453: 3450: 3447: 3446: 3443: 3440: 3439: 3436: 3433: 3432: 3429: 3428:-->default 3426: 3425: 3422: 3420: 3417: 3414: 3413: 3410: 3409: 3408: 3407: 3402:pointer array 3401: 3398: 3397: 3396: 3395: 3394: 3392: 3381: 3378: 3376: 3373: 3372: 3369: 3366: 3364: 3361: 3360: 3357: 3354: 3352: 3349: 3348: 3345: 3342: 3340: 3337: 3336: 3333: 3330: 3328: 3325: 3324: 3321: 3318: 3315: 3314: 3311: 3310: 3309: 3308: 3304: 3301: 3297: 3293: 3289: 1618: 1616: 1611: 1610:constant time 1607: 1606:index mapping 1418:"D" 1412:"M" 1406:"S" 1400:"A" 1378: 1376: 1375:linear search 1372: 1368: 1366: 1358: 1354: 1350: 1346: 1342: 1337: 1332: 1330: 1324: 1322: 1318: 1314: 1307: 1303: 1299: 1295: 1291: 1286: 1284: 1278: 1276: 1272: 1265: 1261: 1256: 1252: 1232: 1226: 1219: 1218:constant time 1215: 1211: 1210: 1209: 1208: 1201: 1196: 1193: 1188: 1187:linear search 1183: 1182: 1178: 1174: 1172: 1167: 1165: 1161: 1157: 1145: 1143: 1140: 1139: 1136:-->Divide 1135: 1133: 1130: 1129: 1125: 1123: 1120: 1119: 1115: 1113: 1110: 1109: 1105: 1103: 1100: 1099: 1096: 1093: 1090: 1089: 1086: 1085: 1084: 1083: 1079: 1077: 1073: 1069: 1065: 1061: 1057: 1052: 1050: 1046: 1038: 1036: 1034: 1030: 1026: 1022: 1018: 1017:constant time 1014: 1010: 1006: 1002: 997: 995: 991: 983: 981: 979: 974: 970: 964: 962: 958: 954: 950: 946: 942: 938: 934: 929: 927: 923: 919: 913: 911: 907: 903: 899: 891: 889: 887: 883: 879: 875: 871: 863: 861: 859: 853: 851: 847: 843: 839: 835: 831: 827: 823: 819: 814: 812: 808: 794: 791: 790: 786: 783: 782: 779: 776: 774: 771: 770: 767: 766: 765: 764: 763: 762: 758: 755: 753: 749: 745: 741: 737: 733: 729: 724: 722: 717: 713: 706:Table content 705: 703: 701: 697: 693: 689: 685: 681: 677: 672: 670: 666: 662: 658: 654: 650: 646: 642: 634: 632: 630: 625: 616: 614: 611: 608:to execute a 607: 603: 599: 596: 592: 586: 579:Branch tables 578: 576: 574: 570: 566: 561: 559: 555: 546: 543: 540: 537: 536: 532: 529: 526: 525: 522: 519: 516: 513: 512: 508: 505: 502: 501: 498: 495: 492: 489: 488: 484: 481: 478: 477: 474: 471: 468: 465: 464: 460: 457: 455: 452: 451: 447: 444: 441: 440: 436: 433: 431: 428: 427: 423: 421: 418: 416: 413: 412: 409: 406: 405: 403: 402:constant time 397: 395: 391: 387: 383: 379: 375: 371: 367: 366:architectures 363: 359: 355: 354:binary search 351: 350:linear search 347: 346:constant time 343: 339: 335: 331: 327: 319: 317: 315: 312: 308: 304: 300: 296: 288: 283: 279: 278: 275: 271: 267: 266: 262: 257: 253: 251: 247: 243: 239: 235: 231: 227: 223: 222:program label 219: 215: 213: 210: 206: 202: 201: 199: 198: 195:Typical usage 194: 192: 188: 186: 182: 178: 175: 171: 166: 165: 161: 157: 153: 149: 145: 140: 136: 132: 123: 113: 110: 102: 99:February 2009 91: 88: 84: 81: 77: 74: 70: 67: 63: 60: – 59: 55: 54:Find sources: 48: 44: 38: 37: 32:This article 30: 26: 21: 20: 4816:Control flow 4780: 4684:Donald Knuth 4656: 4651: 4634: 4629: 4618: 4592:. Retrieved 4585:the original 4572: 4557: 4553: 4464: 4453: 4446: 4438: 4431: 4420: 4412: 4409:Donald Knuth 4401: 4394: 4391:Donald Knuth 4379: 4354: 4333: 4282: 4270: 4201:(especially 4197:even by the 4155: 4128: 4114: 4092:, in that a 4083: 4066:"reflective" 4055: 4042: 4039:Spreadsheets 4033: 4027: 4021: 4005: 3998: 3991: 3985:-->Divide 3984: 3977: 3970: 3963: 3956: 3928: 3915: 3910: 3905: 3900: 3895: 3888: 3883: 3878: 3873: 3868: 3861: 3856: 3851: 3846: 3841: 3834: 3829: 3824: 3819: 3814: 3807: 3802: 3797: 3792: 3787: 3780: 3775: 3770: 3765: 3760: 3753: 3748: 3743: 3738: 3733: 3726: 3721: 3716: 3711: 3706: 3699: 3694: 3689: 3672: 3671: 3653: 3648: 3633: 3628: 3622: 3613: 3608: 3603: 3598: 3591: 3586: 3581: 3576: 3569: 3564: 3559: 3554: 3547: 3542: 3537: 3532: 3525: 3520: 3515: 3510: 3503: 3498: 3482: 3481: 3476: 3473: 3463:-->?other 3462: 3456:-->Divide 3455: 3448: 3441: 3434: 3427: 3399: 3388: 3379: 3374: 3367: 3362: 3355: 3350: 3343: 3338: 3331: 3326: 3319: 3306: 3305: 3299: 3291: 3287: 3285: 1615:housekeeping 1602: 1363: 1362: 1356: 1352: 1348: 1344: 1340: 1335: 1325: 1320: 1316: 1312: 1311: 1305: 1301: 1297: 1293: 1289: 1279: 1274: 1270: 1269: 1263: 1259: 1254: 1250: 1206: 1205: 1199: 1184: 1169: 1168: 1160:control flow 1153: 1141: 1131: 1121: 1111: 1101: 1081: 1080: 1056:lookup table 1053: 1042: 1029:Donald Knuth 1011:and for the 1004: 1000: 998: 987: 965: 957:machine code 949:branch table 930: 926:control flow 914: 895: 876:, such as a 872:storage, on 867: 854: 834:machine code 815: 811:asynchronous 804: 777: 772: 760: 759: 756: 725: 715: 709: 699: 673: 653:propositions 638: 617: 595:machine code 591:branch table 588: 585:Branch table 564: 562: 551: 544: 520: 496: 472: 407: 399: 398: 393: 358:lookup table 325: 323: 292: 258:applications 230:control flow 189: 167: 151: 139:control flow 130: 129: 105: 96: 86: 79: 72: 65: 53: 41:Please help 36:verification 33: 4472:Fred Brooks 4428:Jon Bentley 4351:expressions 4343:indirection 4312:memoization 4261:subroutines 4230:binary file 4221:subroutines 4190:and mostly 4165:detection, 4068:(a form of 4045:spreadsheet 1164:subroutines 994:spreadsheet 980:structure. 973:portability 858:enumerating 752:subroutines 700:implemented 692:subroutines 669:abstraction 661:interpreter 657:subroutines 641:Truth table 598:branch/jump 390:hexadecimal 364:). In most 348:(without a 280:similar to 274:interpreter 228:, to alter 224:or program 148:interpreter 4810:Categories 4669:References 4382:Peter Naur 4375:Quotations 4364:truth flag 4291:and "self 4267:efficiency 4217:primitives 4205:tables in 4195:understood 4192:inherently 4188:ubiquitous 4182:clarity – 4177:Advantages 4161:purposes, 3629:physically 1679:&& 1670:&& 1661:&& 1652:&& 1643:&& 1484:&& 1475:&& 1466:&& 1457:&& 1448:&& 1365:C language 1106:-->Add 1025:quotations 1013:C language 1001:compensate 933:efficiency 922:extensible 906:primitives 830:data types 748:primitives 734:(or other 573:heuristics 569:validation 394:guaranteed 218:subroutine 185:structures 177:references 69:newspapers 4645:1532-1886 4346:utilized) 4300:unsorted) 4159:debugging 4006:-->End 3964:-->Add 3686:alternate 3495:alternate 3435:-->Add 1045:arbitrary 969:platforms 878:flat file 307:algorithm 238:main loop 144:processor 4757:Archived 4720:Archived 4604:cite web 4479:See also 4468:— 4457:— 4443:— 4425:— 4406:— 4388:— 4385:studied. 4355:directly 4349:Complex 4339:overhead 4293:optimize 4163:hot spot 4137:overhead 4133:pointers 4086:bytecode 4074:raw data 3667:for loop 3663:DO WHILE 3477:implicit 1673:Multiply 1664:Subtract 1469:Multiply 1460:Subtract 990:overhead 961:snippets 941:language 882:database 880:or on a 838:pointers 744:pointers 736:run-time 629:overhead 330:raw data 326:directly 311:multimap 301:between 299:portable 282:bytecode 244:using a 220:number, 174:function 4297:metrics 4144:and or 4121:pointer 3945:pointer 3683:input 1 3492:input 1 3416:pointer 3316:input 1 3296:0-based 1646:Default 1487:Default 1367:example 1343:,00,00, 1315:(up to 1292:,00,00, 1273:(up to 1177:IBM/360 1173:example 1095:pointer 1091:input 1 1021:verbose 1005:improve 902:generic 818:encoded 795:action 787:action 740:indexes 716:implies 712:essence 680:boolean 565:minimum 342:pointer 209:pointer 158:-based 83:scholar 4643: 4594:17 May 4564: 4440:values 4308:memory 4236:source 4105:P-code 3690:subr # 3665:' or ' 3499:subr # 3320:subr # 1691:static 1682:Divide 1622:static 1523:sizeof 1478:Divide 1427:static 1382:static 1329:binary 1283:binary 1255:direct 1192:binary 1068:SWITCH 947:using 870:static 846:SWITCH 824:used. 682:style 647:(or a 624:opcode 424:Array 386:EBCDIC 360:on an 334:offset 226:offset 212:lookup 135:tables 85: 78: 71: 64: 56: 4588:(PDF) 4581:(PDF) 4545:Notes 4422:table 4251:cache 4142:loops 4125:index 3948:array 3695:count 3649:after 3504:count 3419:array 3391:ASCII 1694:const 1625:const 1430:const 1385:const 1321:times 1264:times 1260:times 852:) ). 842:index 792:value 784:value 415:ASCII 382:ASCII 338:index 205:index 90:JSTOR 76:books 4641:ISSN 4610:link 4596:2016 4562:ISBN 4186:are 4146:jump 4129:data 3929:CT4P 3700:jump 3645:loop 3641:jump 3400:CT2P 3275:CT1p 3269:goto 3254:CT1x 1700:CT1x 1697:char 1634:CT1p 1628:void 1592:CT1p 1586:goto 1574:CT1p 1568:goto 1520:< 1439:CT1p 1433:void 1388:char 1175:for 1064:jump 1062:(or 1060:call 728:type 649:tree 556:and 430:null 248:for 133:are 62:news 4682:by 4271:all 4219:or 4064:or 3673:CT4 3657:or 3483:CT3 3307:CT2 3300:not 3288:not 1655:Add 1617:). 1562:CT1 1529:CT1 1502:int 1496:for 1451:Add 1391:CT1 1357:CT1 1306:CT1 1200:CT1 1082:CT1 1027:by 953:JIT 750:or 723:). 696:HLL 684:AND 552:In 533:00 509:00 485:00 461:00 448:00 437:00 420:Hex 384:or 352:or 340:or 240:in 203:an 172:or 146:or 45:by 4812:: 4606:}} 4602:{{ 4522:– 4430:, 4411:, 4393:, 4043:A 3292:do 3263:); 3242:}; 1685:}; 1559:== 1550:if 1538:++ 1532:); 1490:}; 1421:}; 1353:02 1349:03 1345:04 1341:01 1302:08 1298:12 1294:16 1290:04 688:OR 620:If 615:. 589:A 545:02 541:53 530:.. 527:.. 521:03 517:4D 506:.. 503:.. 497:04 493:44 482:.. 479:.. 473:01 469:41 458:40 445:.. 442:.. 434:00 336:, 4612:) 4598:. 4370:) 4209:) 3916:1 3911:0 3906:6 3901:- 3896:- 3889:- 3884:0 3879:0 3874:? 3869:? 3862:- 3857:0 3852:4 3847:d 3842:D 3835:- 3830:0 3825:3 3820:m 3815:M 3808:- 3803:0 3798:2 3793:s 3788:S 3781:- 3776:0 3771:1 3766:a 3761:A 3754:- 3749:0 3744:7 3739:e 3734:E 3727:- 3722:0 3717:5 3712:- 3707:- 3639:( 3614:0 3609:0 3604:? 3599:? 3592:0 3587:4 3582:d 3577:D 3570:0 3565:3 3560:m 3555:M 3548:0 3543:2 3538:s 3533:S 3526:0 3521:1 3516:a 3511:A 3380:0 3375:? 3368:4 3363:D 3356:3 3351:M 3344:2 3339:S 3332:1 3327:A 3278:; 3272:* 3260:x 3257:( 3251:= 3248:i 3236:, 3230:, 3224:, 3218:, 3212:, 3206:, 3200:, 3194:, 3188:, 3182:, 3176:, 3170:, 3164:, 3158:, 3152:, 3146:, 3140:, 3134:, 3128:, 3122:, 3116:, 3110:, 3104:, 3098:, 3092:, 3086:, 3080:, 3074:, 3068:, 3062:, 3056:, 3050:, 3044:, 3038:, 3032:, 3026:, 3020:, 3014:, 3008:, 3002:, 2996:, 2990:, 2984:, 2978:, 2972:, 2966:, 2960:, 2954:, 2948:, 2942:, 2936:, 2930:, 2924:, 2918:, 2912:, 2906:, 2900:, 2894:, 2888:, 2882:, 2876:, 2870:, 2864:, 2858:, 2852:, 2846:, 2840:, 2834:, 2828:, 2822:, 2816:, 2810:, 2804:, 2798:, 2792:, 2786:, 2780:, 2774:, 2768:, 2762:, 2756:, 2750:, 2744:, 2738:, 2732:, 2726:, 2720:, 2714:, 2708:, 2702:, 2696:, 2690:, 2684:, 2678:, 2672:, 2666:, 2660:, 2654:, 2648:, 2642:, 2636:, 2630:, 2624:, 2618:, 2612:, 2606:, 2600:, 2594:, 2588:, 2582:, 2576:, 2570:, 2564:, 2558:, 2552:, 2546:, 2540:, 2534:, 2528:, 2522:, 2516:, 2510:, 2504:, 2498:, 2492:, 2486:, 2480:, 2474:, 2468:, 2462:, 2456:, 2450:, 2444:, 2438:, 2432:, 2426:, 2420:, 2414:, 2408:, 2402:, 2396:, 2390:, 2384:, 2378:, 2372:, 2366:, 2360:, 2354:, 2348:, 2342:, 2336:, 2330:, 2324:, 2318:, 2312:, 2306:, 2300:, 2294:, 2288:, 2282:, 2276:, 2270:, 2264:, 2258:, 2252:, 2246:, 2240:, 2234:, 2228:, 2222:, 2216:, 2210:, 2204:, 2198:, 2192:, 2186:, 2180:, 2174:, 2168:, 2162:, 2156:, 2150:, 2144:, 2138:, 2132:, 2126:, 2120:, 2114:, 2108:, 2102:, 2096:, 2090:, 2084:, 2078:, 2072:, 2066:, 2060:, 2054:, 2048:, 2042:, 2036:, 2030:, 2024:, 2018:, 2012:, 2006:, 2000:, 1994:, 1988:, 1982:, 1976:, 1970:, 1964:, 1958:, 1952:, 1946:, 1940:, 1934:, 1928:, 1922:, 1916:, 1910:, 1904:, 1898:, 1892:, 1886:, 1880:, 1874:, 1868:, 1862:, 1856:, 1850:, 1844:, 1838:, 1832:, 1826:, 1820:, 1814:, 1808:, 1802:, 1796:, 1790:, 1784:, 1778:, 1772:, 1766:, 1760:, 1754:, 1748:, 1742:, 1736:, 1730:, 1724:, 1718:, 1712:, 1706:{ 1703:= 1676:, 1667:, 1658:, 1649:, 1640:{ 1637:= 1631:* 1604:" 1595:; 1589:* 1580:} 1577:; 1571:* 1565:) 1556:x 1553:( 1547:{ 1541:) 1535:i 1526:( 1517:i 1514:; 1511:0 1508:= 1505:i 1499:( 1481:, 1472:, 1463:, 1454:, 1445:{ 1442:= 1436:* 1415:, 1409:, 1403:, 1397:{ 1394:= 1371:C 1236:) 1233:1 1230:( 1227:O 1142:? 1132:D 1122:M 1112:S 1102:A 959:" 686:/ 538:S 514:M 490:D 466:A 454:@ 112:) 106:( 101:) 97:( 87:· 80:· 73:· 66:· 39:.

Text is available under the Creative Commons Attribution-ShareAlike License. Additional terms may apply.

Index