| 
		        
			        |  |  
			        |  |  
					| Авторизация |  
					|  |  
			        |  |  
			        | Поиск по указателям |  
			        | 
 |  
			        |  |  
			        |  |  
			        |  |  
                    |  |  
			        |  |  
			        |  |  |  | 
		|  |  
                    | Scott M.L. — Programming Language Pragmatics |  
                    |  |  
			        |  |  
                    | Предметный указатель |  
                    | | Scope rules, dynamic scoping      116 129—132 321 466 590 Scope rules, naming-related pitfalls      149—151
 Scope rules, static (lexical) scoping      115—129 130 429
 Scope rules, static (lexical) scoping, module types and classes      126—129
 Scope rules, static (lexical) scoping, modules      122—126
 Scope rules, static (lexical) scoping, nested subroutines      118—122
 Scope rules, symbol table      132—137
 Scope stack of symbol table      134
 Scope, closed      125 137
 Scope, hole in      121 149—152
 Scope, open      125 533
 Scott, Dana S.      102 202
 Scott, Michael L.      ii 727 731
 Sebesta, Robert W.      28
 Second-class value      143 320
 Section (slice) of an array      367 367—368 774
 Seek operation for files      406
 Segment      509
 Segment switching in MIPS assembler      513
 Segmented memory      383
 Selection      271—279
 Selection, case/switch statements      275—279
 Selection, described      249
 Selection, guarded      304
 Selection, if statement      69—71 101 271—272
 Selection, short-circuited conditions      272—275
 Self-scheduling      775
 Semantic analysis      165—202
 Semantic analysis, action routine      166 179—180
 Semantic analysis, attribute flow      166 170—178
 Semantic analysis, attribute grammar      166 168—170
 Semantic analysis, attribute space management      180—191
 Semantic analysis, intermediate code generation and      18—19 166 174
 Semantic analysis, phase of compilation      16
 Semantic analysis, role of semantic analyzer      166—168
 Semantic analysis, syntax tree annotation      191—197
 Semantic check      see “Type checking”
 Semantic check, dynamic, array subscripts      377 379
 Semantic check, dynamic, association list      137
 Semantic check, dynamic, by linker      523
 Semantic check, dynamic, C-style cast      559
 Semantic check, dynamic, case/switch statement      349
 Semantic check, dynamic, coercion      338
 Semantic check, dynamic, dangling reference      392
 Semantic check, dynamic, disabling      167
 Semantic check, dynamic, Lisp      401
 Semantic check, dynamic, overflow, in binary arithmetic      264
 Semantic check, dynamic, Scheme      451
 Semantic check, dynamic, set type      343
 Semantic check, dynamic, short-circuit evaluation      265
 Semantic check, dynamic, subrange type      327 342
 Semantic check, dynamic, subtype assignment      363
 Semantic check, dynamic, type clash      131
 Semantic check, dynamic, type conversion      335
 Semantic check, dynamic, uninitialized variable      259—260
 Semantic check, static, ML type system      345
 Semantic check, static, set type      344
 Semantic check, static, subrange type      342
 Semantic check, static, type cast      337
 Semantic function      169—170 171 173 179
 Semantic hook      183
 Semantic stack      189—190
 Semantics, axiomatic      167 170 202 314 590 731
 Semantics, denotational      170 270 602
 Semantics, dynamic      19 130 165
 Semantics, static      19 130 165
 Semantics, syntax vs.      31—32 165
 Semaphore, binary      695
 Semaphore, bounded buffer example      697
 Semaphore, scheduler-based synchronization      695—696 697
 send operation      710—714
 send operation, blocking      710
 send operation, buffering      711—712
 send operation, emulation of alternatives      712—713
 send operation, error reporting      712
 send operation, synchronization semantics      710—711 712
 send operation, syntax and language integration      714
 Sense-reversing barrier      691
 Sentential form      36
 sentinel value      312 317
 Separate compilation for module emulation      123
 Separate compilation in C and C++      123 151—154 517 534
 Separate compilation in Fortran      117
 Separate compilation in Modula-2      540
 Separate compilation, binding time      107
 Separate compilation, integrated environment      515
 Separate compilation, interprocedural code improvement and      241
 Separate compilation, module subdivision      125 540—541
 Separate compilation, naming-related pitfalls      151—155
 Separate compilation, type checking      516—517
 sequencing      249 250 270—271 599
 Sequent Computer Corporation      670
 Sequential file      406
 Set      381—382
 Sethi, Ravi      28 202 527 785
 setjmp routine in C      473
 sh      9
 Shallow binding for name lookup in Lisp      139
 Shallow binding of referencing environment      116 141
 Shallow comparisons and assignments (copies)      415
 Shamir, Eliahu      102
 Shape of an array      338 369
 Shapiro, Ehud      731
 Shared inheritance      555 570 572—573
 Shared memory      687—705
 Shared memory, busy-wait synchronization      688—691
 Shared memory, coherence problem      668—670
 Shared memory, history      662
 Shared memory, implicit synchronization      703—705
 Shared memory, multiprocessor architecture      667 668—670
 Shared memory, scheduler implementation      692—694
 Shared memory, scheduler-based synchronization      671 684 694—703
 Shared memory, software distributed shared memory (S-DSM)      317 672 731
 Sharp, Oliver J.      786
 Shasta      317
 Shell (command interpreter)      9 160 793
 Shift-reduce (LR) parsing      48—51 75—86
 short-circuit evaluation      265 265—267 272—275
 Short-circuit evaluation and normal-order evaluation      651
 Short-circuit evaluation in expression evaluation      265—267
 Short-circuit evaluation in selection statement      272—275
 Short-circuit evaluation, code generation      175
 Short-circuit evaluation, making do without      310
 Side effect      254
 Side effect, assignment operator      260—261
 Side effect, empty type and      328 347
 Side effect, exception handler      469
 Side effect, functional language and      254 592 593 606—607 622 648 649
 Side effect, high-order function and      609
 Side effect, in-line expansion of subroutine and      442
 Side effect, insn annotation      502
 Side effect, iteration      300 308
 Side effect, lazy evaluation and      606—607
 Side effect, local optimization      740
 Side effect, normal-order evaluation      302
 Side effect, ordering within expressions and      263 265
 Side effect, Prolog      637
 Side effect, Scheme      599 600
 Side effect, sequencing and      270—271
 Side effect, short-circuit evaluation and      266
 Side effect, Von Neuman languages and      6
 Siewiorek, Daniel P.      247
 signal operation in monitor      698—700
 Signaling NaN, floating point      214 259
 Significand of floating-point number      212
 Significant comment (pragma)      47—48 422 441 466
 Silbershatz, A.      730
 Silicon Graphics, Inc.      670
 simple type      325
 Simula, abstraction-based point of view      323
 
 | Simula, cactus stacks      477 Simula, call-by-name parameters      451
 Simula, classes      128 793
 Simula, coroutines      474 548
 Simula, described      793
 Simula, DETACH operation      475 478 548 674
 Simula, initialization of objects      547 552
 Simula, method binding      555
 Simula, module types      126 539
 Simula, object-oriented programming and      530
 Simula, virtual methods      555 557
 Simulation      480—483
 Single-assignment variable      705 781
 Sipser, Michael      102
 Sisal as functional language      6 592 649
 Sisal, compilation      623
 Sisal, dependence analysis      704
 Sisal, described      793—794
 Sisal, Fibonacci function      301
 Sisal, old keyword      300 301
 Sisal, synchronization      704
 Skolem constant      645
 Skolem function      645
 Skolemization      642 644—645
 Slice of an array      367 367—368 774
 Smalltalk      577—580
 Smalltalk as object-oriented language      7 530
 Smalltalk, abstraction-based point of view      323
 Smalltalk, anthropomorphism      549 577
 Smalltalk, assignment      578
 Smalltalk, associativity      578
 Smalltalk, blocks      578
 Smalltalk, class hierarchy      536 549
 Smalltalk, classes      128
 Smalltalk, container class      580
 Smalltalk, described      794
 Smalltalk, enumeration-controlled loop      578—579
 Smalltalk, evolution of languages      3
 Smalltalk, expression syntax      443 484 578
 Smalltalk, GNU interpreter      499
 Smalltalk, graphical interface      404
 Smalltalk, if construct      443 578
 Smalltalk, implementation      13 582 586
 Smalltalk, infix (mixfix) notation      251
 Smalltalk, initialization of objects      548 549
 Smalltalk, late binding      13—14
 Smalltalk, logically-controlled loop      579—580
 Smalltalk, messages      577
 Smalltalk, metaclass      549
 Smalltalk, method binding      555
 Smalltalk, multiple inheritance      586
 Smalltalk, object model      577—580
 Smalltalk, Object superclass      535
 Smalltalk, parameter passing      444
 Smalltalk, polymorphism      108 147 321
 Smalltalk, precedence      252 578
 Smalltalk, programming environment      15 29 404 577
 Smalltalk, recursion      580
 Smalltalk, self      531 580
 Smalltalk, self-descriptive types      340
 Smalltalk, super      538
 Smalltalk, type checking      108 321 559 560
 Smalltalk, type system      322
 Smalltalk, variables as references      256 560
 Smalltalk, visibility of class members      544
 Smith, James E.      247
 SMP (symmetric multiprocessor)      667
 Sneeringer, M. J.      425
 Snobol as homoiconic language      649
 Snobol as special purpose language      3
 Snobol, described      794
 Snobol, pattern matching      349
 Snobol, scope rules      116 129
 Snobol, strings      371 381
 Snobol, type checking      349
 Snyder, Alan      489
 Socit des Outils du Logiciel      790
 Socket      706
 Software distributed shared memory (S-DSM)      317 672 731
 Software pipelining      765—767
 Solomon, Marvin H.      316
 Sort, quicksort      647 653
 Sort, topological      761
 Space sharing      683
 Sparc architecture, approach (CISC vs. RISC)      243
 Sparc architecture, condition codes      217
 Sparc architecture, GNU back end      500
 Sparc architecture, register windows      241
 Sparc architecture, SMPs      670
 Special form in Lisp/Scheme      596
 speculative execution      705
 Spilling of registers      235 507 763
 SPIM      xx
 Spin lock      688—690 692 693 725 727
 Spin-then-yield lock      692 693 694 695
 spinning      see “Busy-wait synchronization”
 Spreadsheet      6
 Spur Lisp      731
 SR in statement      306 718
 SR, capabilities      708
 SR, case statement, lack of      304
 SR, concurrency      673
 SR, described      794
 SR, early reply      681
 SR, guarded commands      304 316
 SR, implementation      525
 SR, implicit receipt      714
 SR, integration of sequential and concurrent constructs      679 681
 SR, line breaks      33
 SR, memory model      707
 SR, message screening (selection)      307 718
 SR, naming for communication      707
 SR, nondeterminacy      304
 SR, parallel loops      675
 SR, receive operation      714 715
 SR, remote invocation      711
 SR, semaphores      695
 SR, send operation      711
 SR, threads      474 673 676 730
 SSA (static single assignment) form      745 746—749 786
 STACK      111—112 428—431 509
 stack frame      111 428
 Stack pointer      112 221 224 226 428
 Stack, 680x0      437—440
 Stack, MIPS      434—437
 Stack-based language      496—497
 Stack-based storage allocation      109 111—112 391 428—431 476—477
 Stallings, William      247
 Stansifer, Ryan      657 792
 Start symbol of CFG      35
 Statement in predicate calculus      641
 Statement, expression vs.      254
 Static (lexical) scope      115—129 130 429
 Static binding      107
 Static chain      120 429
 Static link      120 429
 Static semantics      19 130 165
 Static single assignment (SSA) form      745 746—749 786
 Static storage allocation      109—111 391
 static type checking      321 330 344 385
 Statically typed language      321
 stdio library in C/C++      410 412 456
 Stearns, Richard E.      102 202
 Steele, Guy L. Jr.      793
 Stop-and-copy garbage collection      400 426
 Storage allocation      108—115 (see also “Garbage collection”)
 Storage allocation, arrays      369—370
 Storage allocation, explicit vs. implicit deallocation      114—115
 Storage allocation, garbage collection      109 114—115
 Storage allocation, heap-based      109 113—114 391
 
 | 
 |  |  |  | Реклама |  |  |  |  |  |