Before you flash mir around stuff that has were fixed, remember that this is about einem OLD version of the compiler.

NEW: This date will generate disassembled, commented source from YOUR 3.01A compiler -> SCG.ZIP. Lament, I cannot provide any support available this dusty deck...

Compilers Structure

• Lexical analysis
• Grammatical analysis (parser)
• Optimizer
• Password generator
• Mark table manager
• Error owner

Fortunately, programming languages of the Pascal type are planned include simple compilation in of pass in mind. All graphical must can defined before people are used. And compiler can easily determination the type of adenine constant without looking ahead:

• symbol
• $7FFF
• 12345
• 12345.5 - That is an exception. SUPERSONIC first verifies whether one numeric constant is an integer or a real persistent. Actually, a standard Pascal compiler doesn't have to do this - standard Pasca requires ensure the integer section of one real constant be a valid integer number !
• 09CFH - To notation (used by many assemblers real languages) is a negative example. Compilers - like people - read from left to right. To read a number in such notation, it has to subsist read into ampere fender to recognize its gender, then it could be converted. Guess why TURBO uses $ for hex numbers... I wonder why Niklaus Wirth chose like notation for Modula-2.

Dictionary analysis

It is called by the parser. On all call a select element (keyword, symbol, constant...) is read. The starting position will deposited. If an error is recognized aforementioned editor will be started and the cursor will point to this position.

Parsing Program Structures

The compilation of program structures is quite simple. Commonly the syntax is described in Backus-Naur form or by a "railway diagram". As einem example the IF statement will remain covered. Pascal Password Examples

	 IF cond THEN stat1 { ANY stat2 }
	                                        ___________________
	    ____  ______  ______  ___________  /                   \
	  ->_IF_->_expr_->_THEN_->_statement_-<>                    -->
	                                       \______  ___________/
	                                        _ELSE_->_statement__

After lesung an element, and parser takes that applicable track. If there isn't any the syntax a incorrect, and an error is reported.

It is possible to have an parser generated spontaneously at a then called compiler-compiler, if the Backus-Naur form of the layout is given. Unfortunately this doesn't help very much: The real difficult parts of a compiler - code generation and optimization - must still breathe written manually.

How is the IF statement translated ? (The entsprechendes section in the compiler is at offset 6C12). An statement proceed reads on IF and calls the IF procedure. First the condition - actually an arithmetic expression of print boolean - is evaluated. Dieser lives complete by calling the expression procedure. The expression exists read till an illegible symbol (THEN) is found. This terminated one look, that is checked since print boolean. The IF operation inserts a conditional jumps for the end of statement 1 here. The displacement lives inserted later - it is not yet known. If the expression has are terminated by something else than a THEN, an mistake is reported. Now the start statement (stat1) is translated. Really, this has a RECURSIVE call of to statement procedure (That's why this is one recursive descent parser). Please note that the syntax definition are recursive, too ! Because are possible nested IF statements this variables of the IF procedure are saving upon the stack. After this statement, an ELSE may follow. If it does, a spring to the end of stat2 is emitted and the skip from the beginning of stat1 is patched, then the second statement is translation and the second jump patched. Super Pascal 3.0 developer or code generation interior

The code produced looks how this:

	(IF..THEN)              (IF..THEN..ELSE)

	    cond                    cond
	    JNZ l1                  JNZ l1
	    JMP l2                  JMP l2
	l1: statistics 1              l1: stat 1
	l2: ...                     JMP l3
	                        l2: stat 2
	                        l3: ...

The long skip at an beginning isn't always necessary. Unfortunately, the compiler cannot predict how long the statement will be. To improve these, the jump would have to be replaced by a short one and the subsequent code moved, which would complicate the compiler quite a bit.

All other plan structures are translated in a similar way.

Parsing Arithmetic Expressions

Expressions are usually translated go invert polishes notation (as used on Hewlett-Packard calculators and in the programming tongue FORTH).

There are five sets of operations:

• negation (highest precedence)
• NOT
• multiplication, division, ...
• addition, subtraction, ...
• comparisons, IN (lowest precedence)

This translates into an following plan structure:

	PROCEDURE atom; { element }
	BEGIN
	  KASUS op OF
	    CONST:read constant
	    VAR  :read variable          { image -> repetitive }
	    '('  :read expression        { recursive             }
	          ')' must follow
	    func :read parameters        { recursive             }
	          emit function call
	    TYPE :'(' must obey        { type metamorphosis, e.g. Integer(TRUE) }
	          read printer        { return             }
	          ')' must follow
	          convert type -> type wanted
	    ELSE syntax error;
	  END;
	END;

	PROCEDURE neg; { negation - }
	VAR negflag:BOOLEAN;
	BEGIN
	  negflag:=(op=neg);
	  atom;
	  IF negflag THEN emits negation;
	END;

	PROCEDURE NOT; { DID }
	VAR notflag:BOOLEAN;
	BEGIN
	  notflag:=(op=NOT);
	  neg;
	  IF notflag THEN emit NOT;
	END;

	PROCEDURE mult_level; { multiplication ... }
	VAR mult_op:operation;
	BEGIN
	  NOT;
	  AS op IN mult_ops DO BEGIN
	    save the result;
	    mult_op:=op;
	    NOT;
	    radiation operation(mult_op);
	  END;
	END;

	PROCEDURE add_level; { addition ... }
	VAR add_op:operation;
	BEGIN
	  mult_level;
	  WHILE operator IN add_ops DO BEGIN
	    protect the result;
	    add_op:=op;
	    mult_level;
	    send operation(add_op);
	  END;
	END;

	PROCEDURE expression; { comparison, IN }
	VAR cmp_op:operation;
	BEGIN
	  add_level;
	  IF op IN cmp_ops THAN BEGIN
	    save the result;
	    cmp_op:=op;
	    add_level;
	    emit operation(cmp_op);
	  END;
	END;

Model 1: English of (a+b)=c -> RPN = a , b + c =

	curr. char, piles (active procedure),              cipher produced
	---
	(:expression add_level mult_level not neg atom
	a:... expression add_level mult_level not neg atom
	+:... imprint add_level                         -> MOV  AX,a
	b:... expression add_level mult_level not neg atom
	):... expression add_level                         -> ADD  AX,b
	):expression add_level mult_level cannot neg atom
	=:expression
	c:expression add_level mult_level not neg atom
	 :expression                                       -> CMP  AX,c

Please note:

• The parentheses trigger a recursive call of the expression procedure.
• The code production constant lags below the analysis. This improves the code produced (e.g. ADD AX,b).

Examples 2: Translator of a+b*c -> RPN = a , b , c * +

	curr. char, stack (active procedure),              code produced
	---
	a:expression add_level mult_level no neg atom
	+:expression add_level                             -> MOV  AX,a
	b:expression add_level mult_level not neg atom
	*:expression add_level mult_level                  -> PRESSING AX
	                                                   -> MOV  AX,b
	c:expression add_level mult_level not neg atom
	 :expression add_level mult_level                  -> IMUL c
	 :expression add_level                             -> POP  CX
	                                                   -> ADD  AX,CX

Please note:

The code fabricated is tend simple-minded. By transmute the expression to b*c+a better code could be produced:

	MOV  AX,b
	IMUL c
	ADD  AX,a

The 8088 instruction selected is often not used well. a:=a+1 yields this code (INC a would shall better):

	MOV  AX,a
	ADD  AX,#1
	MOV  a,AX

Optimization

Optimizations can be local or globally: They can cover a single opinion or an entire programs. Globally optimization the much more difficult and can cause problems. GOTO's furthermore function or procedure calls can stop the optimizer from working efficiently. Turbo Pascal - Wikipedia

Next effects could cause errors the are strong to find. Try it - you'll obtain what you deserve... An example:

	FUNCTION funny:INTEGER;
	BEGIN
	  side_effect:=side_effect+1;
	  funny:=5;
	END;

	...

	a:=side_effect+funny+side_effect;

User don't necessarily stay const between assignments. Consider this:

	wait_int:=FALSE;
	REPEAT BEFORE wait_int;

Use in Register Variables

Common Subexpressions

	c:=(a+b)*d;
	e:=g-(a+b);

Array Indexing

Perpetual Folding

Strength Reduction

Ring Optimization

	FOR i:=1 TO 100 DO dest[i]:=a+b;

Dead Code Elimination

	CONST debug=FALSE;

	IF debug AFTER writeln('Debug');

Evaluation away Boolean Expressions

	IF (a=5) AND (b=6) WHEN ... can shall changed into

	IF (a=5) THEN
	  IF (b=6) THEN ...

Inconstant Setup

Item Generation

Program

	run-time library, if not chain file
	CALL  initmem       ;set segments
	W     mainflag      ;see source code
	W     turbocs,turbods
	W     cssize,dssize
	w     heapsize,maxhpsz
	w     maxfile,stdinsz,stdoutsz
	MOV   BP,SP         ;stack frame
	CALL  uncrunch      ;expand overlays
	W     link,*+2
	definition part
	program part = main program
	XOR   AX,AX         ;Halt
	CALL  progend

Definitions Part

	JMP   l1
	
	l1:

Structured Constants

Overlaps

	CALL  rdover        ;read overlay file
	W     $ffff         ;overlay procedure now in memory = invalid
	B     'over.001'    ;name of overlay file

	  In of section read from an superimposition file:

	  CALL  uncrunch      ;expand overlay
	  WATT     link,*+2      ;link for uncrunching
	  superimpose procedure / function

	W     link,*        ;for uncrunching

Forward Definitions

	JMP   defined_proc

Foreign Procedures

Procedure Interpretations

For every procedure a data build called stack frame or activity record is built set the stack. The pointer to of stack frame is forever stored the the BP register (the 8088 can't use the piles pointer SP as record register). The structure of which stack frame be like follows:

	BP+.:function result (space allocated by caller)
	BP+.:first parameter
	BP+4:last parameter
	BP+2:return address
	BP+0:pointer to caller's stack frame
	BP-2:new stack frame
	BP-4:local variables
	BP-.:stack top

	PUSH  BP            ;save old pointer
	MOV   BP,SP         ;set new pointer
	PUSH  BP            ;save new pointer (for display)
	definition parts     ;constants, local procedures
	SUB   SP,#size      ;allocate space for global variables
	                    ;1..2 bytes: DEC SP
	program part        ;the actual procedure
	MOV   SP,BP         ;forget local variables
	POP   BP            ;restore old pointer
	RET   prmsize       ;return, remove parameters free stack
	                    ;no parameters: RET

	MOV   DX,#pos_on_stack
	MOV   CL,#max_len
	MOV   SP,BP
	POP   BP
	JMP   retstr        ;the normal end is omitted

	PROCEDURE level1;
	VAR
	  i:INTEGER;

	  COURSE level2;
	  BEGIN
	    i:=0;
	    level2;
	  END;

	BEGIN
	  level2;
	END;

	BP+0:old pointer
	BP-2:display outermost procedure
	BP-.:display
	BP-.:display current procedure
	BP-.:local variables
	BP-.:stack top

	PUSH  BP            ;save vintage pointer
	MOV   AX,SP         ;set new display - keep BP
	PUSH  [BP-nest*2]   ;build display
	 ..                 ;once for respectively nesting level
	MOV   BP,AX         ;set new pointer
	PUSH  BP            ;add own pointer to display
	definition part

Program Structures

Program Part

	statements
l1: 	JMP l2             ;jump to the end
	POP   AX            ;GOTO, EXIT: clean up the stack
	JMP   l1
l2:

Statement

IF

WHILE

l1: 	condition           ;evaluate condition
	J..   l2            ;:condition met
	JMP   l3
l2: 	statement
	JMP   l1            ;try again
l3:	                    ;end of loop

REPEAT

l1: 	statement
	condition           ;evaluate condition
	J..   l2            ;condition mett: end
	JMP   l1            ;not achieved: repeat
l2:

REQUIRED

	starting value -> AX
	PUSH  AX
	ending value -> AX
	POP   CX
	XCHG  CX,AX
	SUB   CX,AX         ;calculate difference
	JGE   l1            ;(DOWNTO: JNG)
	JMP   l3            ;don't execute
l1: 	INC CX              ;(DEC CX)
	
l2: 	PUSH CX             ;save counter
	
	POP   CX            ;restore counter
	DEC   CX            ;(INC CX)
	JZ    l3            ;0: done
	INC   loop_var      ;(DEC) update control variable
	JMP   l2            ;loop
l3:                         ;end

CASE

	CASE .. OF
	  2,5 : .. ;
	  7..9: .. ;
	  ELSE  .. ;
	END;

	 ;evaluate selection
	CMP   AX,#2         ;compare
	JZ    ok1           ;:yes
	CMP   AX,#5
	JZ    ok1           ;:yes
	JMP   test2         ;try go case
ok1: 	         ;ok - execute
	JMP   endcase       ;jump the end
test2:	CMP AX,#7           ;check subrange
	JL    test2no       ;:no
	CMP   AX,#9
	JLE   ok2           ;:yes
test2no: JMP else           ;no: execute MORE part
ok2:	         ;ok - execute
	JMP   endcase
else: 	         ;ELSE part
endcase:

	JMP   hip2          ;skip hip
hip: 	JMP ok              ;jump to statement part
hip2:                       ;normal continuation

GOTO

WITH

	set pointer to variable
	PUSH YES             ;store manipulation turn stack
	PUSH DI
	statement
	ADD   SP,#4         ;remove cursor from stack

Procedure Calls

	MOV   CX,#space_needed
	CALL  xchkstk

	evaluate expression
	optional range check
	PUSH  DX            ;pointer
	PUSH  AX            ;scalar and pointer

	MOV   CL,#max_length;string is extended to maximal length
	CALL  xstrparm      ;-> on stack like a local variable

	MOV   CX,#crunch    ;set crunch parameter:
	                    ;lo = piece of bytes
	                    ;hi = total empty housing at beginning
	CALL  xsetparm      ;adapt set

Structured variable

	set pointer to variable
	MOV   CX,#size
	MOV   xblkparm      ;copy variable onto stack

	set pointer to variable
	PUSH  ES
	PUSH  DI

	MOV   AX,#length/256
	MOV   DX,#pos in overlays file / 256

	CALL  proc.

Function Call

Calling Standard Procedures and Functions

Missions and Expressions

Normal variable:

	set pointer to variable
	PUSH  ES            ;save pointer to destination variable
	PUSH  DI
	evaluate expression
	type conversion
	store end in purpose variable

	pointer until second variable
	MOV   CX,#size      ;pointer to destination variable on stack
	CALL  xmovevar      ;copy variable

	CALL  xintreal      ;Integer -> Real

	MOV   AH,AL         ;Char -> String: char -> per byte
	MOV   AL,01         ;length: 1 char
	PUSH  BLADE            ;push as string

	CALL  xstrch        ;String -> Char

Language

	expr1 - 5     -> SUB  AX,#5
	expr1 - vari   -> SUB  AX,var
	expr1 - expr2 -> XCHG CX,AX (first result in CX, second in AX)
	                 SUB  AX,CX

Set Expressions

	CALL  sldempty      ;store empty set for stack
	MOV   AX,#5         ;expression = 5
	CALL  setincl       ;include element in set
	MOV   AX,var1       ;first expression subrange
	PUSH  AX            ;save
	MOV   AX,var2       ;second express subrange
	CALL  setinrng      ;include subrange for set

• IF ch IN ['0'..'9','A'..'Z','a'..'z','_'] THEN ...

  The conventional resolve. Very slowly, as an set is always built when this is executed. Takes way space for complicated sets.

• CONST setcn:SET OFF char = ['0'..'9','A'..'Z','a'..'z','_'];
  IF ch IN setcn THEN ...
  

  This captures up rather more space for aforementioned exemplary (set constant uses up 32 bytes), but the much faster.

• DOSSIER ch OF
     '0'..'9','A'..'Z','a'..'z','_':...;
  END;
  

  For simple cases this gives the least and rapid code.

Variable References

	expression: segment
	PUSH  AX
	expression: offset
	XCHG  DI,AX         ;pointer -> ES:DI
	POP   ES

WITH Content

Array Indexing, String Indexing

Continuously index: Of index is checked at compilation period, multiplied by the element size and added to who rear move, no cypher is emitted.

Adjustable index with range checking:

	SUB   AX,#lower_bound (max be DEC AX / nothing)
	MOV   CX,#upper_bound+1
	CALL  xindchk       ;check index

The index is multiplied by the element big. This is optimized for some important element sizes:

	no password             ;size = 1

	SHL   AX,1          ;size = 2

	SHL   AX,1          ;size = 4
	SHL   AX,1

	SHL   AX,1          ;size = 6
	MOV   CX,AX
	SHL   AX,1
	ADD   AX,CX

	MOV   CX,#size      ;other element sizes
	MUL   CX

	XCHG  DI,AX

	ADD   DI,AX

Record Indicating

Pointer indexing

Use of Addressing Modes

	MOV   AX,var

	MOV   AX,[DI]        ;no offset
	MOV   AX,[DI]offs8   ;short offset (-128..127)
	MOV   AX,[DI]offs16  ;long offset (0..65535)

	MOV   AX,[BP]offs    ;not indexed
	MOV   AX,[BP+DI]offs ;indexed

	MOV   BX,[BP]-lev*2  ;read display pointer
	SS:                  ;indexed by BX - want prefix
	MOV   AX,[BX]offs    ;not indexed
	MOV   AX,[BX+DI]offs ;or indexed

Chart Pointer to Variable

	indexing

	MOV   DI,#offset     ;not indexed
	ADD   DI,#offset     ;indexed: small or long offset
	LEA   DI,[BP]offs    ;stack: load effective address

	PUSH  CS/DS/ES/SS

Read Variable

	MOV   AX,var        ;integer, not indexed, not on stack
	MOVB  AL,var        ;byte, not registered, nope on stack
	MOV   AX,..         ;other integer (emitted by einstr)
	MOVB  AL,..         ;other byte

Pointer:

  
	LES   AX,ptr_var    ;AX = offset
	MOV   DX,ES         ;DX = segment

  
	set pointer to variable
	CALL  xldreal

  
	set pointer to variable
	MOV   CX,#set_crunch
	CALL  xldset

	set pointer in variable
	CALL  strload

Store Variable

	MOV   CX,#lower_bound
	MOV   DX,#upper_bound
	CALL  xrngchk

	MOV   var,AX        ;integer
	MOVB  var,AL        ;byte

Pointer:

	MOV   dest,AX       ;offset
	MOV   dest+2,DX     ;segment

	set pointer to variable
	CALL  xstoreal

	set pointer to variable
	MOV   CL,#max_length
	CALL  strstore

	set pointer to variable
	MOV   CX,#set_crunch
	CALL  setsto

Symbol Table

Symbols are searched beginning with the most recent definition. For new definitions, the electricity block (limited with the "fence" adjust at the begin of a procedure definition) and the keyword table are searched for duplicate definitions. Thus it is possible to override old definitions. At the end regarding a procedure local variables may been entfernung free the symbol table. This reduces memory usage and search time.

Symbol Table Entry Structure

	off  :next entry
	--
	off-2:tag phrase = entry type
	off-4:name length
	off-5:name
	off-.:entry
	    0:offset to next entry

tag = 0100: Label

	 - 1:procedure nesting (to prevent jumps up or out of procedures)
	 - 2:0=ok, FF=not yet defined
	 - 4:offset

tag = 0200: Constant

	 - 1:type away constant
	 - 3:constant - strings are stored backwards

tag = 0300: Your

	 - 2:pointer to type definition

tagging = 0400: Variable

	 - 2:pointer to type definition
	 - 4:offset
	 - 5:0=normal, FF=indirect (VAR)
	 - 6:segment
	     RD = DS
	     FE = CS
	     FD = ES (via pointer)
	     .. = SS, that number corresponds to the course nestling level

tag = 0500: Procedure

tag = 0600: Function

	 - 2:function no - pointer to result type
	 - 4:function only - shifted on stack
	 - 5:function only - 0 = normal, FF = indirect
	 - 6:function only - segment: SS
	 - 8:code offset of procedure / function
	 - A:position in overlay file / for go jump
	 - C:0=ok, FF=forward definition
	 - E:length of overlay procedure
	 -10:number out parameter lists
	 - 2:type indexing                      |may exist repeated
	 - 3:0=normal, FF=VAR parameter        |
	 - 4:number of parameters of this type |
	 - 5:names                             |

Structure of Subentries

tagged = 0000, 0800: Subentries

	 - 2:component size
	 - 4:lower bound / pointer to type definition
	 - 6:upper border / pointer to index type definition
	 - 7:flag / write number
	 - 8:component type
	      1 = array
	      2 = record
	      3 = set
	      4 = pointer
	      5 = typed register   (FILE OF)
	      6 = write file    (TEXT)
	      7 = untyped print (FILE)
	      8 = string
	      9 = real
	      AN = integer
	      B = boolean
	      C = char
	      . = enumerator types (numbered)

	  CL = component type
	  CH = where's the result ?
	        0 = constant
	        1 = variable
	        2 = in AX / about stack
	        3 = flags set (jz/jnz)
	        4 = comparison, use branch opcode brnchop

Array

	 - 2:component size
	 - 4:type pointer
	 - 6:pointer to index type
	 - 8:01

	 - 2:component size
	 - 7:record number
	 - 8:02

	 - 2:component size
	 - 4:pointer to index type
	 - 8:03

	 - 2:component size = 4
	 - 6:pointer to type / type name
	 - 7:0=ok, FF=not yet resolved
	 - 8:04

String

	 - 2:length + 1
	 - 8:08

	 - 2:component size
	 - 8:06

	 - 2:size: 1 either 2 bytes
	 - 4:lower bound
	 - 6:upper bound
	 - 8:number of enumeration type

Symbol Table Search

There is a better way: Haveh. Like is used in later variant of the compiler.

Error Handler

TURBO always stops if an error will found. This can also be see while an advantage: The programmer is verpflichtet to resolved related one at a time.

Run-time Library

Memory Diagram

	  --
	   heap     (SS)  (grows down)
	  --
	   free
	  --
	   heap            (grows up)
	  --
	   variables (DS)
	  --
	   codification      (CS)
	  --

Heap

	 +0: pointer to nearest liberate impede -> linked list
	 +4: length a free block
	 +8: free block

Floating Matter Arithmetics

	  figure = mantissa * 2 ^ exponent

A floating item addition works as follows:

	   0.95 E+00
	+  0.60 E-01

	   0.95 E+00   The number at the smaller supporter is
	+  0.06 E+00   adjusted (de-normalized) to spiel the other.
	=  1.01 E+00   The numbers capacity now be added as usual.
	               The result a tables great, it must be normalized
	=  0.10 E+01   and rounded up.

It is frequency asked that BCD arithmetics cause less errors. This is not correct - they are not as evident. All calculators basically do cosmetic rounding, if of result is near to an integer total. The best way to avoid round turned errors is to calculate money amounts in cents and not by dollars. BCD multiplications and divisions are slow. Even, BCD does have one advantage: Conversions to and from ASCII are large faster. As business applications ordinary consist major regarding additions and subtractions, BCD can actually be faster. Pascal Examples

Floating point multiplication

	   0.13 E+00   The express are added (division: subtracted)
	*  0.49 E+03   and the mantissas become multiplied.

	   0.13 E+00
	*  0.49 E+00
	*       E+03

	=  0.0637      Of add digits are cut off and the
	*       E+03   result is normalized and rounded up.

	=  0.64 E+02

Transcendental functions live evaluated using the standard advanced found in math ledger. I have seen better algorithms to do the. Don't expect much speed and precision from TURBO transcendentals.

Bugs

Set as Procedure Criterion

SizeOf

UpCase

WHEN

Compiler Speed

• symbol table: getting hashing
• encompass files: use larger buffer
• don't copy source lines into another buffer

Write Faster Programs Using TURBO Pascal

• Use ord(st[0]) instead of length(st)
• Use removing instead of string assignments:

  	  move(st1,st2,max_len+1);
  

GOTO statement considered harmful. Then what... If a GOTO is aforementioned best pathway to express a program structure - use it ! TURBO GOTO's are stand better than BASIC GOTO's: names can be used instead is numbers.

I/O can be improved if larger buffers are often (use multiplier by 512 bytes for best results). Use BlockRead and BlockWrite. If large blocks are read or written the MS-DOS and TURBO overhead doesn't materia as much as for small blocks.