| 
		        
			        |  |  
			        |  |  
					| Àâòîðèçàöèÿ |  
					|  |  
			        |  |  
			        | Ïîèñê ïî óêàçàòåëÿì |  
			        | 
 |  
			        |  |  
			        |  |  
			        |  |  
                    |  |  
			        |  |  
			        |  |  |  | 
		|  |  
                    | Scott M.L. — Programming Language Pragmatics |  
                    |  |  
			        |  |  
                    | Ïðåäìåòíûé óêàçàòåëü |  
                    | | Anthropomorphism in object-oriented languages      549 576 577 Anti-dependence      231 760
 APL, arrays      368 371 454
 APL, described      789
 APL, precedence      252
 APL, scope rules      116 129
 Appel, Andrew W.      28 202 527 785
 Applicative-order evaluation      301 659
 Applicative-order evaluation, functional programming      604—606 617
 Applicative-order evaluation, overview      301—303
 Apt, Krzysztof R.      730
 Architecture and language design      799
 Architecture of a processor      203
 Argument (actual parameter)      427 442—443
 Array      365—379
 Array, address calculations      375—378
 Array, allocation of      369—370
 Array, associative      365
 Array, conformant      147 370 453—454
 Array, declaration of      365—367
 Array, described      327
 Array, dimensions and bounds      369—373
 Array, dope vector      378—379
 Array, elaboration of      369—370 379
 Array, full-array operations      367
 Array, lifetime      369—370
 Array, memory layout      373—379
 Array, set implementation      382
 Array, shape      338 369
 Array, slice      367 367—368 774
 Array, syntax and operations      365—372
 Assembler      2 14 507 510—514 527
 Assembly language as low-level IF      497
 Assembly language, Algol 60 and      451
 Assembly language, assigning addresses to names      514
 Assembly language, compiler generation of      11—12 219 496 510
 Assembly language, control flow      267
 Assembly language, dump vs. disassembler      511
 Assembly language, emitting instructions      511—513
 Assembly language, history      1—3 105 218
 Assembly language, interpreter implementation      14
 Assembly language, load instruction      226
 Assembly language, machine independence      105
 Assembly language, machine language vs.      11—12
 Assembly language, MIPS example for GCD program      22—24
 Assembly language, pseudoassembler notation      225—227
 Assembly language, semantic analysis and      19 167
 Assembly language, store instruction      226
 Assembly language, type, lack of      320 321
 Assembly-level architecture      203—248
 Assembly-level architecture, compiling for modern processors      227—241
 Assembly-level architecture, data representation      209—214
 Assembly-level architecture, evolution of processor architecture      218—227
 Assembly-level architecture, instruction set architecture      214—218
 Assembly-level architecture, memory hierarchy      207—209
 Assembly-level architecture, workstation macro-architecture      204—207
 assertion      167 168
 ASSIGNMENT      254—262
 Assignment in expression context      100
 Assignment in functional language      589
 Assignment of subrange type      341—343
 Assignment of subtype      363
 assignment operator      260—262
 Assignment, Ada      362—363 380 463 541
 Assignment, Algol 68      257 261
 Assignment, alias      744
 Assignment, array      367 381
 Assignment, associativity      253
 Assignment, bodyless virtual method      557
 Assignment, C      253 257
 Assignment, C++      259 551 557
 Assignment, Clu multiple assignment      262
 Assignment, combination assignment operator      260—262
 Assignment, constant propagation      737
 Assignment, deep comparisons and (copies)      415 720
 Assignment, denotational semantics      323
 Assignment, Eiffel      559
 Assignment, equality testing and      414—416
 Assignment, expression evaluation      254—262
 Assignment, Fortran      257
 Assignment, function return value      458
 Assignment, functional language, lack of      383 593 622
 Assignment, implicit synchronization      703
 Assignment, initialization and      258—260 551
 Assignment, Java      259 260
 Assignment, Kill sets      751
 Assignment, lazy evaluation and      606
 Assignment, loop invariant      755—756
 Assignment, ML      389
 Assignment, Modula-2      540
 Assignment, Modula-3      445
 Assignment, multiple inheritance      566 571
 Assignment, orthogonality      256—258
 Assignment, parallel loop      675—676
 Assignment, parsing of      183 184—185
 Assignment, Pascal      149 361—362
 Assignment, Perl      262
 Assignment, reference count      396 397
 Assignment, reference model of variables      255—256 258 384
 Assignment, reversible      291
 Assignment, Scheme      599—600
 Assignment, shallow comparisons and (copies)      415
 Assignment, Simula      548
 Assignment, single-assignment variable      705 781
 Assignment, Smalltalk      578
 Assignment, static single assignment (SSA) form      745 786
 Assignment, string      380 381
 Assignment, type compatibility      337 340—341
 Assignment, value model of variables      254—255
 Assignment, Von Neuman languages and      6
 Association list (A-list)      137—139 598
 associative array      365
 Associativity      38
 Associativity and attribute flow      172
 Associativity in expression evaluation      251—253 262
 Associativity, parsing      18 38—39 76 168
 Associativity, Smalltalk      578
 AST (Abstract Syntax Tree)      see “Syntax tree”
 Atom in Lisp      385 401 402
 Atom in logic programming      624 625 635 640 641
 Atomic operation      686
 Atomic operation, multiprocessor scheduling      687
 Atomic operation, primitive      688 689
 Atomic operation, primitive, universal      689 690 726
 Atomic operation, reentrant thread scheduler      692
 Atomic operation, semaphore      695
 Atomic operation, uniprocessor scheduling      686
 Attribute      19
 Attribute grammar, jump code generation      273
 Attribute grammar, L-attributed      173 273
 Attribute grammar, noncircular      174
 Attribute grammar, S-attributed      171
 Attribute grammar, translation scheme      174
 Attribute grammar, well-defined      174
 Attribute in Diana      499
 Attribute of an Ada type      371 424 454 463
 Attribute stack, bottom-up parsing      180—183
 Attribute stack, top-down parsing      186—189
 Attribute storage      see “Attribute space
 Attribute, flow      170—178
 Attribute, grammar      168—170 172
 Attribute, inherited      171 273
 Attribute, space management      180—191
 Attribute, space management, ad hoc management      179—180 189—191
 Attribute, space management, automatic management      186—189
 Attribute, space management, bottom-up evaluation      181—185
 Attribute, space management, inherited attribute      182—185
 Attribute, space management, top-down evaluation      186—191
 Attribute, synthesized      170 273 313
 Attributed syntax tree      see “Syntax tree”
 
 | Auto-increment/decrement addressing mode      111 216 438 739 Automata theory      87—93 315 424
 Automatic storage reclamation      see “Garbage collection”
 Automaton      see “Turing machine”
 Automaton, cellular      371
 Automaton, deterministic      87
 Automaton, deterministic finite      39 424 603—604
 Automaton, finite      41 79 87 88—92 280
 Automaton, nondeterministic      87
 Automaton, push-down      39 87 92—93
 Available expression      750 782
 awk      9 365
 Axiom of Choice      645
 Axiomatic semantics      167 170 202 314 590 731
 Back end of a compiler      16 (see also “Code generation” “Code “Linking”)
 Back end of a compiler, assembly      510—514
 Back end of a compiler, described      25 491
 Back end of a compiler, example      492—496
 Back end of a compiler, GNU (gcc)      499—500 501
 Back end of a compiler, nonoptimizing structure      503
 Back end of a compiler, phases and passes      496
 Back end of a compiler, structure      491—496
 Back end of a compiler, syntax tree as input      19
 Back end of a compiler, variations in      491—492
 Back end of a simulator      483
 Backoff in synchronization      689
 Backtracking      631 659
 Backtracking, Icon generator      290 291
 Backtracking, Prolog      630 631 635—637 649 704
 Backus, John W.      35 102 592 657 790
 Backus-Naur Form for LL(1) calculator grammar      64
 Backus-Naur Form, extended      35
 Backus-Naur Form, IDL vs.      499
 Backus-Naur Form, operators excluded from      35
 Backward chaining in logic language      629 659
 Bacon, David F.      786
 Bag of tasks model of concurrency      670 775
 Bagrodia, R. L.      730
 Banerjee, Utpal      786
 Bar-Hillel, Y.      102
 Barendregt, Hendrik Pieter      657
 Barrier      688
 Barrier in busy-wait synchronization      690—691
 Barrier in RTL      502
 Barrier, semaphores for      696
 Base (parent) class      121 535 537
 Base (parent) type of set      382
 Base (parent) type of subrange      326
 Basic as Von Neuman language      6
 Basic block      234 492 741
 Basic block, global optimization and      241
 Basic block, identification by code generator      492
 Basic block, instruction scheduling      760 762
 Basic block, redundancy elimination      733 734 740—745 746
 Basic block, register allocation      234 775
 Basic, arrays      453
 Basic, described      789
 Basic, ease of use      4
 Basic, evolution of languages      3
 Basic, exponentiation      8
 Basic, goto statement      3
 Basic, interpreter      11
 Basic, scope rules      117
 Basic, type system      322
 Basic, Visual Basic      7 789
 Basis of a set of LR items      77 78 79 81
 Batch processing      85 661 662
 BCD (binary-coded decimal) arithmetic      209 211 224 245 324
 Beck, Leland L.      527
 Bell Telephone Laboratories      152 789 792 794
 Bell, C. Gordon      247
 Bernstein, A. J.      730
 Bershad, Brian N      731
 Beta abstraction      619 620
 Beta reduction      616
 Big-endian byte order      210 421
 Binary instrumentation      786
 Binary search      278 309 314 472
 Binary translation      786
 Binary-coded decimal (BCD) arithmetic      209 211 224 245 324
 Binding      106 (see also “Type checking”)
 Binding in association list      137
 Binding in lambda expression      596
 Binding in nested subroutines      118
 Binding of communication channel to remote procedure      679
 Binding of exception handler      465 466
 Binding of module variables      123—124
 Binding time      106 106—108 142 417 453
 Binding with dynamic scoping      129 130
 Binding, backtracking and      631
 Binding, binding time      106 106—108 142 417 453
 Binding, deep      116 139 141—143 678
 binding, dynamic      107 465
 Binding, dynamic method binding      162 529 554—564
 Binding, dynamic method binding, abstract class      557
 Binding, dynamic method binding, first-class subroutines and      563
 Binding, dynamic method binding, member lookup      557—561
 Binding, dynamic method binding, related concepts      561—564
 Binding, dynamic method binding, type of reference object and      556—557
 Binding, dynamic method binding, virtual and nonvirtual methods      55—57
 Binding, late      10 13—14 108 141 321
 Binding, lifetime of      109
 Binding, overloading      132 144—146
 Binding, Prolog      648
 Binding, redeclaring objects      121—122
 Binding, rules for referencing environment      106 116 139—144 678
 Binding, Scheme      596—597
 Binding, scope of      115—116
 Binding, shallow      116 139 141
 Binding, static      107
 Binding, static method binding      555 556
 Birtwistle, Graham M.      489
 bison/yacc      40 79 85—87 102
 Black, Andrew      586
 BLISS      321 322
 Blizzard      317
 Block (syntactic unit)      270
 Block (syntactic unit) and co-begin threads      674 676
 Block (syntactic unit), C scope rules      152
 Block (syntactic unit), entry time      107
 Block (syntactic unit), evolution of languages      3
 Block (syntactic unit), exception handling      465 466 468 469 470 472
 Block (syntactic unit), exception-based error recovery      61
 Block (syntactic unit), parsing      17—18
 Block (syntactic unit), Pascal scope rules      150—151
 Block (syntactic unit), scope of declarations      121
 Block (syntactic unit), Smalltalk      578 579
 Block copy operation      354 379
 Blocking (of process/thread)      see “Scheduler-based synchronization”
 Blocking (of process/thread) in web-based application      665
 Blocking (of process/thread), message passing      709—712 714
 Blocking (of process/thread), multiprocessor scheduling      687
 Blocking (of process/thread), preemption      685
 Blocking (of process/thread), reentrant thread scheduler      692
 Blocking (of process/thread), RPC      721
 Blocking (of process/thread), scheduler-based synchronization      671 694—703
 Blocking (of process/thread), system call      682
 Blocking (of process/thread), uniprocessor scheduling      684
 BNF (Backus-Naur Form)      35 64 499
 Bobrow, D. G.      426
 Bochmann, G. V.      202
 Body of coroutine      476
 Body of Horn clause      624 626 630 640
 Body of iterator      480
 Body of lambda abstraction      617
 Body of loop      280—282 285 287 294 295
 Body of loop, in Haskell      33
 Body of loop, in Occam      33
 Body of loop, in Smalltalk      580
 Body of loop, pipelined      765
 
 | 
 |  |  |  | Ðåêëàìà |  |  |  |  |  |