{$optimize 1} {---------------------------------------------------------------} { } { Expression } { } { Evaluate expressions } { } { Note: The expression evaluator uses the scanner to fetch } { tokens, but IT IS ALSO USED BY THE SCANNER to evaluate } { expressions in preprocessor commands. This circular } { dependency is handle by defining all of the expression } { evaluator's external types, constants, and variables in the } { CCOMMON module. The only procedure from this module used by } { the scanner is Expression, which is declared as an external } { procedure in the scanner. } { } { External Variables: } { } { startExpression - tokens that may start an expression } { bitDisp,bitSize - bit field disp, size } { unsigned - is the bit field unsigned? } { isBitField - is the field a bit field? } { } { External Subroutines: } { } { AssignmentConversion - do type checking and conversions for } { assignment statements } { CompareToZero - Compare the result on tos to zero. } { DisposeTree - dispose of an expression tree } { DoSelection - Find the displacement & type for a } { selection operation } { Expression - handle an expression } { FreeTemp - place a temporary label in the available label } { list } { GenerateCode - generate code from a fully formed expression } { tree } { GetTemp - find a temporary work variable } { InitExpression - initialize the expression handler } { UsualBinaryConversions - performs the usual binary } { conversions } { UsualUnaryConversions - performs the usual unary conversions } { } {---------------------------------------------------------------} unit Expression; {$LibPrefix '0/obj/'} interface uses CCommon, Table, CGI, Scanner, Symbol, MM, Printf; {$segment 'EXP'} var startExpression: tokenSet; {tokens that can start an expression} {set by DoSelection} {------------------} bitDisp,bitSize: integer; {bit field disp, size} unsigned: boolean; {is the bit field unsigned?} isBitField: boolean; {is the field a bit field?} {misc} {----} lastwasconst: boolean; {did the last GenerateCode result in an integer constant?} lastconst: longint; {last integer constant from GenerateCode} lastWasNullPtrConst: boolean; {did last GenerateCode give a null ptr const?} {---------------------------------------------------------------} procedure AssignmentConversion (t1, t2: typePtr; isConstant: boolean; value: longint; genCode, checkConst: boolean); { TOS is of type t2, and is about to be stored to a variable of } { type t1 by an assignment or a return statement. Make sure } { this is legal, and do any necessary type conversions on t2, } { which is on the top of the evaluation stack. Flag an error } { if the conversion is illegal. } { } { parameters: } { t1 - type of the variable } { t2 - type of the expression } { isConstant - is the rhs a constant? } { value - if isConstant = true, then this is the value } { genCode - should conversion code be generated? } { checkConst - check for assignments to constants? } procedure CompareToZero(op: pcodes); { Compare the result on tos to zero. } { } { This procedure is used by the logical statements to compare } { _any_ scalar result to zero, giving a boolean result. } { } { parameters: } { op - operation to use on the compare } procedure DisposeTree (tree: tokenPtr); { dispose of an expression tree } { } { parameters: } { tree - head of the expression tree to dispose of } procedure DoSelection (lType: typePtr; tree: tokenPtr; var size: longint); { Find the displacement & type for a selection operation } { } { parameters: } { lType - structure/union type } { id - tag field name } { size - disp into the structure/union } { } { returned in non-local variables: } { bitDisp - displacement to bit field } { bitSize - size of bit field } { unsigned - is the bit field unsigned? } { isBitField - is the field a bit field? } { } { variables: } { expressionType - set to the type of the field } procedure Expression (kind: expressionKind; stopSym: tokenSet); { handle an expression } { } { parameters: } { kind - Kind of expression; determines what operations } { and what kind of operands are allowed. } { stopSym - Set of symbols that can mark the end of an } { expression; used to skip tokens after syntax } { errors and to block certain operations. For } { example, the comma operator is not allowed in } { an expression when evaluating a function } { parameter list. } { } { variables: } { realExpressionValue - value of a real constant } { expression } { expressionValue - value of a constant expression } { expressionType - type of the constant expression } procedure FreeTemp(labelNum, size: integer); { place a temporary label in the available label list } { } { parameters: } { labelNum - number of the label to free } { size - size of the variable } { } { variables: } { tempList - list of free labels } procedure GenerateCode (tree: tokenPtr); { generate code from a fully formed expression tree } { } { parameters: } { tree - top of the expression tree to generate code from } { } { variables: } { expressionType - result type of the expression } function GetTemp(size: integer): integer; { find a temporary work variable } { } { parameters: } { size - size of the variable } { } { variables: } { tempList - list of free labels } { } { Returns the label number. } procedure InitExpression; { initialize the expression handler } function UsualBinaryConversions (lType: typePtr): baseTypeEnum; { performs the usual binary conversions } { } { inputs: } { lType - type of the left operand } { expressionType - type of the right operand } { } { result: } { The base type of the operation to perform is } { returned. Any conversion code necessary has been } { generated. } { } { outputs: } { expressionType - set to result type } function UsualUnaryConversions: baseTypeEnum; { performs the usual unary conversions } { } { inputs: } { expressionType - type of the operand } { } { result: } { The base type of the operation to perform is returned. } { Any conversion code necessary has been generated. } { } { outputs: } { expressionType - set to result type } procedure GetLLExpressionValue (var val: longlong); { get the value of the last integer constant expression as a } { long long (whether it had long long type or not). } {---------------------------------------------------------------} implementation const {notAnOperation is also used in TABLE.ASM} notAnOperation = 200; {used as the icp for non-operation tokens} var {structured constants} {--------------------} startTerm: tokenSet; {tokens that can start a term} {misc} {----} errorFound: boolean; {was there are error during generation?} {-- Procedures imported from the parser ------------------------} procedure Match (kind: tokenEnum; err: integer); extern; { insure that the next token is of the specified type } { } { parameters: } { kind - expected token kind } { err - error number if the expected token is not found } function TypeName: typePtr; extern; { process a type name (used for casts and sizeof/_Alignof) } { } { returns: a pointer to the type } function MakeFuncIdentifier: identPtr; extern; { Make the predefined identifier __func__. } { } { It is inserted in the symbol table as if the following } { declaration appeared at the beginning of the function body: } { } { static const char __func__[] = "function-name"; } { } { This must only be called within a function body. } function MakeCompoundLiteral(tp: typePtr): identPtr; extern; { Make the identifier for a compound literal. } { } { parameters: } { tp - the type of the compound literal } procedure AutoInit (variable: identPtr; line: longint; isCompoundLiteral: boolean); extern; { generate code to initialize an auto variable } { } { parameters: } { variable - the variable to initialize } { line - line number (used for debugging) } { isCompoundLiteral - initializing a compound literal? } {-- External unsigned math routines ----------------------------} function lshr (x,y: longint): longint; extern; function udiv (x,y: longint): longint; extern; function uge (x,y: longint): longint; extern; function ugt (x,y: longint): longint; extern; function ule (x,y: longint): longint; extern; function ult (x,y: longint): longint; extern; function umod (x,y: longint): longint; extern; function umul (x,y: longint): longint; extern; {-- External 64-bit math routines ------------------------------} { Procedures for arithmetic and shifts compute "x := x OP y". } procedure umul64 (var x: longlong; y: longlong); extern; procedure udiv64 (var x: longlong; y: longlong); extern; procedure div64 (var x: longlong; y: longlong); extern; procedure umod64 (var x: longlong; y: longlong); extern; procedure rem64 (var x: longlong; y: longlong); extern; procedure add64 (var x: longlong; y: longlong); extern; procedure sub64 (var x: longlong; y: longlong); extern; procedure shl64 (var x: longlong; y: integer); extern; procedure ashr64 (var x: longlong; y: integer); extern; procedure lshr64 (var x: longlong; y: integer); extern; function ult64(a,b: longlong): integer; extern; function uge64(a,b: longlong): integer; extern; function ule64(a,b: longlong): integer; extern; function ugt64(a,b: longlong): integer; extern; function slt64(a,b: longlong): integer; extern; function sge64(a,b: longlong): integer; extern; function sle64(a,b: longlong): integer; extern; function sgt64(a,b: longlong): integer; extern; {-- External conversion functions; imported from CGC.pas -------} procedure CnvXLL (var result: longlong; val: extended); extern; procedure CnvXULL (var result: longlong; val: extended); extern; function CnvLLX (val: longlong): extended; extern; function CnvULLX (val: longlong): extended; extern; {---------------------------------------------------------------} function Unary(tp: baseTypeEnum): baseTypeEnum; { usual unary conversions } { } { This function returns the base type actually loaded on the } { stack for a particular data type. This corresponds to C's } { usual unary conversions. } { } { parameter: } { tp - data type } { } { result: } { Stack type. } begin {Unary} if tp in [cgByte,cgUByte] then tp := cgWord; Unary := tp; end; {Unary} function UsualBinaryConversions {lType: typePtr): baseTypeEnum}; { performs the usual binary conversions } { } { inputs: } { lType - type of the left operand } { expressionType - type of the right operand } { } { result: } { The base type of the operation to perform is } { returned. Any conversion code necessary has been } { generated. } { } { outputs: } { expressionType - set to result type } var rType: typePtr; {right type} lt,rt: baseTypeEnum; {work variables} function CommonRealType (lt, rt: baseTypeEnum): baseTypeEnum; { Compute the common real type of two types, where at least } { one of the types is a real type. } { } { inputs: } { lt, rt - the two operand types } { } { outputs: } { expressionType - set to result type } begin {CommonRealType} if (lt = cgComp) and (rt = cgComp) then lt := cgComp else if (lt in [cgExtended,cgComp]) or (rt in [cgExtended,cgComp]) then lt := cgExtended else if (lt = cgDouble) or (rt = cgDouble) then lt := cgDouble else lt := cgReal; CommonRealType := lt; case lt of cgReal: expressionType := floatPtr; cgDouble: expressionType := doublePtr; cgExtended: expressionType := extendedPtr; cgComp: expressionType := compPtr; end; {case} end; {CommonRealType} begin {UsualBinaryConversions} UsualBinaryConversions := cgULong; if lType^.kind = pointerType then lType := uLongPtr else if lType^.kind = scalarType then if lType^.baseType = cgVoid then begin lType := uLongPtr; Error(66); end; {if} rType := expressionType; if rType^.kind = pointerType then rType := uLongPtr else if rType^.kind = scalarType then if rType^.baseType = cgVoid then begin rType := uLongPtr; Error(66); end; {if} if (lType^.kind = scalarType) and (rType^.kind = scalarType) then begin lt := Unary(lType^.baseType); rt := Unary(rType^.baseType); if lt <> rt then begin if lt in [cgReal,cgDouble,cgExtended,cgComp] then begin if rt in [cgWord,cgUWord,cgLong,cgULong,cgQuad,cgUQuad] then Gen2(pc_cnv, ord(rt), ord(cgExtended)); UsualBinaryConversions := CommonRealType(lt, rt); end {if} else if rt in [cgReal,cgDouble,cgExtended,cgComp] then begin if lt in [cgWord,cgUWord,cgLong,cgULong,cgQuad,cgUQuad] then Gen2(pc_cnn, ord(lt), ord(cgExtended)); UsualBinaryConversions := CommonRealType(lt, rt); end {else if} else if lt = cgUQuad then begin if rt in [cgWord,cgUWord,cgLong,cgULong] then Gen2(pc_cnv, ord(rt), ord(cgUQuad)); UsualBinaryConversions := cgUQuad; expressionType := uLongLongPtr; end {else if} else if rt = cgUQuad then begin if lt in [cgWord,cgUWord,cgLong,cgULong] then Gen2(pc_cnn, ord(lt), ord(cgUQuad)); UsualBinaryConversions := cgUQuad; expressionType := uLongLongPtr; end {else if} else if lt = cgQuad then begin if rt in [cgWord,cgUWord,cgLong,cgULong] then Gen2(pc_cnv, ord(rt), ord(cgQuad)); UsualBinaryConversions := cgQuad; expressionType := longLongPtr; end {else if} else if rt = cgQuad then begin if lt in [cgWord,cgUWord,cgLong,cgULong] then Gen2(pc_cnn, ord(lt), ord(cgQuad)); UsualBinaryConversions := cgQuad; expressionType := longLongPtr; end {else if} else if lt = cgULong then begin if rt in [cgWord,cgUWord] then Gen2(pc_cnv, ord(rt), ord(cgULong)); UsualBinaryConversions := cgULong; expressionType := uLongPtr; end {else if} else if rt = cgULong then begin if lt in [cgWord,cgUWord] then Gen2(pc_cnn, ord(lt), ord(cgULong)); UsualBinaryConversions := cgULong; expressionType := uLongPtr; end {else if} else if lt = cgLong then begin if rt in [cgWord,cgUWord] then Gen2(pc_cnv, ord(rt), ord(cgLong)); UsualBinaryConversions := cgLong; expressionType := longPtr; end {else if} else if rt = cgLong then begin if lt in [cgWord,cgUWord] then Gen2(pc_cnn, ord(lt), ord(cgLong)); UsualBinaryConversions := cgLong; expressionType := longPtr; end {else if} else {one operand is unsigned in and the other is int} begin UsualBinaryConversions := cgUWord; expressionType := uIntPtr; end; {else} end {if} else begin {types are the same} UsualBinaryConversions := lt; if lt = cgWord then {update types that may have changed} expressionType := intPtr; end; {else} end {if} else Error(66); end; {UsualBinaryConversions} function UsualUnaryConversions{: baseTypeEnum}; { performs the usual unary conversions } { } { inputs: } { expressionType - type of the operand } { } { result: } { The base type of the operation to perform is returned. } { Any conversion code necessary has been generated. } { } { outputs: } { expressionType - set to result type } var et: baseTypeEnum; {work variables} begin {UsualUnaryConversions} UsualUnaryConversions := cgULong; if expressionType^.kind = scalarType then begin et := Unary(expressionType^.baseType); UsualUnaryConversions := et; if et = cgWord then {update types that may have changed} expressionType := intPtr; end {if} {else if expressionType^.kind in [arrayType,pointerType] then UsualUnaryConversions := cgULong}; end; {UsualUnaryConversions} procedure DisposeTree {tree: tokenPtr}; { dispose of an expression tree } { } { parameters: } { tree - head of the expression tree to dispose of } begin {DisposeTree} if tree <> nil then begin DisposeTree(tree^.left); DisposeTree(tree^.middle); DisposeTree(tree^.right); dispose(tree); end; {if} end; {DisposeTree} procedure ValueExpressionConversions; { Perform type conversions applicable to an expression used } { for its value. These include lvalue conversion (removing } { qualifiers), array-to-pointer conversion, and } { function-to-pointer conversion. See C17 section 6.3.2.1. } { } { variables: } { expressionType - set to type after conversions } begin {ValueExpressionConversions} expressionType := Unqualify(expressionType); if expressionType^.kind = arrayType then expressionType := MakePointerTo(expressionType^.aType) else if expressionType^.kind = functionType then expressionType := MakePointerTo(expressionType); end; {ValueExpressionConversions} procedure AssignmentConversion {t1, t2: typePtr; isConstant: boolean; value: longint; genCode, checkConst: boolean}; { TOS is of type t2, and is about to be stored to a variable of } { type t1 by an assignment or a return statement. Make sure } { this is legal, and do any necessary type conversions on t2, } { which is on the top of the evaluation stack. Flag an error } { if the conversion is illegal. } { } { parameters: } { t1 - type of the variable } { t2 - type of the expression } { isConstant - is the rhs a constant? } { value - if isConstant = true, then this is the value } { genCode - should conversion code be generated? } { checkConst - check for assignments to constants? } var baseType1,baseType2: baseTypeEnum; {temp variables (for speed)} kind1,kind2: typeKind; {temp variables (for speed)} procedure CheckConstantRange(t1: typePtr; value: longint); { Check for situations where an implicit conversion will } { change the value of a constant. } { } { Note: This currently only addresses conversions to 8-bit } { or 16-bit integer types, and intentionally does not } { distinguish between signed and unsigned types. } var min,max: longint; {min/max allowed values} begin {CheckConstantRange} if t1^.cType = ctBool then begin min := 0; max := 1; end {if} else if t1^.baseType in [cgByte,cgUByte] then begin min := -128; max := 255; end {else if} else if t1^.baseType in [cgWord,cgUWord] then begin min := -32768; max := 65536; end {else if} else begin min := -maxint4-1; max := maxint4; end; {else} if (value < min) or (value > max) then Error(186); end; {CheckConstantRange} begin {AssignmentConversion} kind1 := t1^.kind; kind2 := t2^.kind; if genCode then if checkConst then if kind2 <> definedType then if tqConst in t1^.qualifiers then Error(93) else if kind1 in [structType,unionType] then if t1^.constMember then Error(93); if kind2 = definedType then AssignmentConversion(t1, t2^.dType, false, 0, genCode, checkConst) else if kind1 = definedType then AssignmentConversion(t1^.dType, t2, false, 0, genCode, checkConst) else if kind2 in [scalarType,pointerType,enumType,structType,unionType,arrayType,functionType] then case kind1 of scalarType: begin if ((lint & lintConstantRange) <> 0) then if isConstant then CheckConstantRange(t1, value); baseType1 := t1^.baseType; if baseType1 in [cgReal,cgDouble,cgComp] then baseType1 := cgExtended; if baseType1 = cgString then Error(64) else if baseType1 = cgVoid then Error(65) else if kind2 = enumType then begin if genCode then Gen2(pc_cnv, ord(cgWord), ord(baseType1)); end {else if} else if kind2 = scalarType then begin baseType2 := t2^.baseType; if baseType2 in [cgString,cgVoid] then Error(47) else if genCode then begin if t1^.cType = ctBool then begin expressionType := t2; CompareToZero(pc_neq); end {if} else Gen2(pc_cnv, ord(baseType2), ord(baseType1)); end {else if} end {else if} else if (t1^.cType = ctBool) and (kind2 in [pointerType,arrayType]) then begin if genCode then begin expressionType := t2; CompareToZero(pc_neq); end {if} end {else if} else Error(47); end; arrayType: ; {any errors are handled elsewhere} functionType,enumConst: Error(47); pointerType: begin if kind2 = pointerType then begin if not CompTypes(t1, t2) then Error(47) else if not looseTypeChecks then if not (t1^.ptype^.qualifiers >= t2^.ptype^.qualifiers) then Error(163); end {if} else if kind2 = arrayType then begin if not CompTypes(t1^.ptype, t2^.atype) and (t1^.ptype^.baseType <> cgVoid) then Error(47) else if not looseTypeChecks then if not (t1^.ptype^.qualifiers >= t2^.atype^.qualifiers) then Error(163); end {if} else if kind2 = scalarType then begin if isConstant and (value = 0) then begin if genCode then Gen2(pc_cnv, ord(t2^.baseType), ord(cgULong)); end {if} else Error(47); end {else if} else Error(47); end; enumType: begin if kind2 = scalarType then begin if ((lint & lintConstantRange) <> 0) then if isConstant then CheckConstantRange(intPtr, value); baseType2 := t2^.baseType; if baseType2 in [cgString,cgVoid] then Error(47) else if genCode then Gen2(pc_cnv, ord(baseType2), ord(cgWord)); end {if} else if kind2 <> enumType then Error(47); end; definedType: AssignmentConversion(t1^.dType, t2, isConstant, value, genCode, checkConst); structType,unionType: if not CompTypes(t1, t2) then Error(47); otherwise: Error(57); end; {case T1^.kind} expressionType := t1; {set the type of the expression} end; {AssignmentConversion} function ExpressionTree (kind: expressionKind; stopSym: tokenSet): tokenPtr; { generate an expression tree } { } { Returns a pointer to the generated tree. The pointer is } { nil, and the variable errorFound is set to true, if an } { error is found. } { } { parameters: } { kind - Kind of expression; determines what operations } { and what kind of operands are allowed. } { stopSym - Set of symbols that can mark the end of an } { expression; used to skip tokens after syntax } { errors and to block certain operations. For } { example, the comma operator is not allowed in } { an expression when evaluating a function } { parameter list. } label 1,2,3; var done,done2: boolean; {for loop termination} doingSizeof: boolean; {used to test for a sizeof operator} doingAlignof: boolean; {used to test for an _Alignof operator} expectingTerm: boolean; {should the next token be a term?} opStack: tokenPtr; {operation stack} parenCount: integer; {# of open parenthesis} stack: tokenPtr; {operand stack} tType: typePtr; {type for cast/sizeof/etc.} op,sp: tokenPtr; {work pointers} procedure ComplexTerm; { handle complex terms } var done: boolean; {for loop termination} namePtr: stringPtr; {name of struct/union fields} sp,tp,tm: tokenPtr; {work pointers} begin {ComplexTerm} while token.kind in [lbrackch,lparench,dotch,minusgtop,plusplusop,minusminusop] do begin case token.kind of lbrackch: begin {subscripting} NextToken; {skip the '['} new(sp); {evaluate the subscript} sp^.token.kind := plusch; sp^.token.class := reservedSymbol; sp^.left := stack; stack := stack^.next; sp^.middle := nil; sp^.right := ExpressionTree(normalExpression, [rbrackch]); sp^.next := stack; stack := sp; Match(rbrackch,24); {skip the ']'} new(sp); {resolve the pointer} sp^.token.kind := uasterisk; sp^.token.class := reservedSymbol; sp^.left := stack; sp^.middle := nil; sp^.right := nil; sp^.next := stack^.next; stack := sp; end; lparench: begin {function call} NextToken; new(sp); {create a parameter list terminator} sp^.token.kind := parameteroper; sp^.token.class := reservedSymbol; sp^.left := nil; sp^.middle := nil; sp^.right := nil; sp^.next := stack; stack := sp; if token.kind <> rparench {evaluate the parameters} then begin done := false; repeat if token.kind in [rparench,eofsy] then begin done := true; Error(35); end {if} else begin new(sp); sp^.token.kind := parameteroper; sp^.token.class := reservedSymbol; sp^.left := nil; sp^.middle := ExpressionTree(normalExpression, [rparench,commach]); sp^.right := stack; sp^.next := stack^.next; stack := sp; if token.kind = commach then NextToken else done := true; end; {else} until done; end; {if} sp := stack; stack := sp^.next; sp^.left := stack; sp^.next := stack^.next; stack := sp; Match(rparench,12); end; dotch,minusgtop: begin {direct and indirect selection} if token.kind = minusgtop then begin new(sp); {e->name == (*e).name} sp^.token.kind := uasterisk; sp^.token.class := reservedSymbol; sp^.left := stack; sp^.middle := nil; sp^.right := nil; sp^.next := stack^.next; stack := sp; token.kind := dotch; token.class := reservedSymbol; end; {if} new(sp); {create a record for the selection operator} sp^.token := token; sp^.left := stack; stack := stack^.next; sp^.middle := nil; sp^.right := nil; sp^.next := stack; stack := sp; NextToken; {skip the operator} if token.kind in [ident,typedef] then begin namePtr := token.name; {record the name} new(sp); {record the selection field} sp^.token := token; sp^.left := nil; sp^.middle := nil; sp^.right := nil; stack^.right := sp; {this becomes the right opnd} NextToken; {skip the field name} end {if} else Error(9); end; plusplusop: begin {postfix ++} NextToken; new(sp); sp^.token.kind := opplusplus; sp^.token.class := reservedSymbol; sp^.left := stack; stack := stack^.next; sp^.middle := nil; sp^.right := nil; sp^.next := stack; stack := sp; end; minusminusop: begin {postfix --} NextToken; new(sp); sp^.token.kind := opminusminus; sp^.token.class := reservedSymbol; sp^.left := stack; stack := stack^.next; sp^.middle := nil; sp^.right := nil; sp^.next := stack; stack := sp; end; otherwise: Error(57); end; {case} end; {while} end; {ComplexTerm} procedure DoOperand; { process an operand } label 1,2; var fnPtr: typePtr; {for defining functions on the fly} fToken: tokenType; {used to save function name token} id: identPtr; {pointer to an id's symbol table entry} np: stringPtr; {for forming global names} sp: tokenPtr; {work pointer} begin {DoOperand} {create an operand on the stack} new(sp); sp^.token := token; sp^.next := stack; sp^.left := nil; sp^.middle := nil; sp^.right := nil; stack := sp; {handle the preprocessor 'defined' function} if kind = preprocessorExpression then if token.name^ = 'defined' then begin expandMacros := false; NextToken; sp^.token.kind := intconst; sp^.token.class := intConstant; if token.kind in [ident,typedef] then begin sp^.token.ival := ord(IsDefined(token.name)); NextToken; end {if} else begin Match(lparench, 13); if token.kind in [ident,typedef] then begin sp^.token.ival := ord(IsDefined(token.name)); NextToken; end {if} else begin Error(9); sp^.token.ival := 0; end; {else} Match(rparench, 12); end; {else} expandMacros := true; goto 1; end; {if} {check for illegal use} id := FindSymbol(token, variableSpace, false, true); if not (kind in [normalExpression,initializerExpression,autoInitializerExpression]) then begin if id <> nil then if id^.itype^.kind = enumConst then goto 2; if kind <> preprocessorExpression then begin op := opStack; while op <> nil do begin if op^.token.kind = sizeofsy then goto 2; op := op^.next; end; {while} Error(41); errorFound := true; end; {if} end; {if} 2: {skip the name} fToken := token; NextToken; {in the preprocessor, all identifiers (post macro replacement) become 0} if kind = preprocessorExpression then begin stack^.token.class := longlongConstant; stack^.token.kind := longlongconst; stack^.token.qval := longlong0; id := nil; end {if} {if the id is not declared, create a function returning integer} else if id = nil then begin if (fToken.name^ = '__func__') and (functionTable <> nil) then id := MakeFuncIdentifier else if token.kind = lparench then begin fnPtr := pointer(GCalloc(sizeof(typeRecord))); {fnPtr^.size := 0;} {fnPtr^.saveDisp := 0;} {fnPtr^.qualifiers := [];} fnPtr^.kind := functionType; fnPtr^.fType := intPtr; {fnPtr^.varargs := false;} {fnPtr^.prototyped := false;} {fnPtr^.overrideKR := false;} {fnPtr^.parameterList := nil;} {fnPtr^.isPascal := false;} {fnPtr^.toolNum := 0;} {fnPtr^.dispatcher := 0;} np := pointer(GMalloc(length(fToken.name^)+1)); CopyString(pointer(np), pointer(fToken.name)); id := NewSymbol(np, fnPtr, ident, variableSpace, declared, false); if ((lint & lintUndefFn) <> 0) or ((lint & lintC99Syntax) <> 0) then Error(51); end {if} else begin Error(31); errorFound := true; end; {else} end {if id = nil} else if id^.itype^.kind = enumConst then begin stack^.token.class := intConstant; stack^.token.kind := intconst; stack^.token.ival := id^.itype^.eval; end; {else if} if id <> nil then id^.used := true; stack^.id := id; {save the identifier} ComplexTerm; {handle subscripts, selection, etc.} 1: end; {DoOperand} procedure Operation; { do an operation } label 1,2,3,4; var baseType: baseTypeEnum; {base type of value to cast} class: tokenClass; {class of cast token} ekind: tokenEnum; {kind of constant expression} kindLeft, kindRight: tokenEnum; {kinds of operands} lCodeGeneration: boolean; {local copy of codeGeneration} op: tokenPtr; {work pointer} op1,op2: longint; {for evaluating constant expressions} rop1,rop2: extended; {for evaluating fp expressions} llop1, llop2: longlong; {for evaluating long long expressions} tp: typePtr; {cast type} unsigned: boolean; {is the term unsigned?} function Pop: tokenPtr; { pop an operand, returning its pointer } begin {Pop} if stack = nil then begin Error(36); errorFound := true; new(stack); {synthesize the missing token} stack^.token.class := intConstant; stack^.token.kind := intconst; stack^.token.ival := 0; stack^.next := nil; stack^.left := nil; stack^.middle := nil; stack^.right := nil; end; {if} Pop := stack; stack := stack^.next; end; {Pop} function RealVal (token: tokenType): extended; { convert an operand to a real value } begin {RealVal} if token.kind in [intconst,charconst,scharconst,ucharconst] then RealVal := token.ival else if token.kind in [uintconst,ushortconst] then begin if token.ival < 0 then RealVal := (token.ival & $7FFF) + 32768.0 else RealVal := token.ival; end {else if} else if token.kind = longconst then RealVal := token.lval else if token.kind = ulongconst then begin if token.lval < 0 then RealVal := (token.lval & $7FFFFFFF) + 2147483648.0 else RealVal := token.lval; end {else if} else if token.kind = longlongconst then RealVal := CnvLLX(token.qval) else if token.kind = ulonglongconst then RealVal := CnvULLX(token.qval) else RealVal := token.rval; end; {RealVal} function IntVal (token: tokenType): longint; { convert an operand to a longint value } begin {IntVal} if token.kind in [intconst,charconst,scharconst,ucharconst] then IntVal := token.ival else if token.kind in [uintconst,ushortconst] then begin IntVal := token.ival & $0000FFFF; end {else if} else {if token.kind in [longconst,ulongconst] then} begin IntVal := token.lval; end; {else} end; {IntVal} procedure GetLongLongVal (var result: longlong; token: tokenType); { convert an operand to a long long value } begin {LongLongVal} if token.kind in [intconst,charconst,scharconst,ucharconst] then begin result.lo := token.ival; if result.lo < 0 then result.hi := -1 else result.hi := 0; end {if} else if token.kind in [uintconst,ushortconst] then begin result.lo := token.ival & $0000FFFF; result.hi := 0; end {else if} else if token.kind = longconst then begin result.lo := token.lval; if result.lo < 0 then result.hi := -1 else result.hi := 0; end {else if} else if token.kind = ulongconst then begin result.lo := token.lval; result.hi := 0; end {else if} else {if token.kind in [longlongconst,ulonglongconst] then} begin result := token.qval; end; {else} end; {LongLongVal} function PPKind (token: tokenType): tokenEnum; { adjust kind of token for use in preprocessor expression } begin {PPKind} if token.kind in [intconst,longconst] then PPKind := longlongconst else if token.kind in [uintconst,ushortconst,ulongconst] then PPKind := ulonglongconst else PPKind := token.kind; end; {PPKind} begin {Operation} op := opStack; {pop the operation} opStack := op^.next; case op^.token.kind of commach: begin {,} op^.right := Pop; op^.left := Pop; end; eqch, {=} pluseqop, {+=} minuseqop, {-=} asteriskeqop, {*=} slasheqop, {/=} percenteqop, {%=} ltlteqop, {<<=} gtgteqop, {>>=} andeqop, {&=} caroteqop, {^=} bareqop: begin {|=} op^.right := Pop; op^.left := Pop; end; colonch: begin {? :} op^.right := Pop; op^.middle := Pop; op^.left := Pop; if op^.right^.token.kind in [intconst,uintconst,ushortconst, longconst,ulongconst,longlongconst,ulonglongconst, charconst,scharconst,ucharconst] then if op^.left^.token.kind in [intconst,uintconst,ushortconst, longconst,ulongconst,longlongconst,ulonglongconst, charconst,scharconst,ucharconst] then if op^.middle^.token.kind in [intconst,uintconst,ushortconst, longconst,ulongconst,longlongconst,ulonglongconst, charconst,scharconst,ucharconst] then begin kindLeft := op^.middle^.token.kind; kindRight := op^.right^.token.kind; {do the usual binary conversions} if (kindRight = ulonglongconst) or (kindLeft = ulonglongconst) then ekind := ulonglongconst else if (kindRight = longlongconst) or (kindLeft = longlongconst) then ekind := longlongconst else if (kindRight = ulongconst) or (kindLeft = ulongconst) then ekind := ulongconst else if (kindRight = longconst) or (kindLeft = longconst) then ekind := longconst else if (kindRight = uintconst) or (kindLeft = uintconst) or (kindRight = ushortconst) or (kindLeft = ushortconst) then ekind := uintconst else ekind := intconst; GetLongLongVal(llop1, op^.left^.token); if (llop1.lo <> 0) or (llop1.hi <> 0) then GetLongLongVal(llop2, op^.middle^.token) else GetLongLongVal(llop2, op^.right^.token); op^.token.kind := ekind; if ekind in [longlongconst,ulonglongconst] then begin op^.token.qval := llop2; op^.token.class := longlongConstant; end {if} else if ekind in [longconst,ulongconst] then begin op^.token.lval := llop2.lo; op^.token.class := longConstant; end {if} else begin op^.token.ival := long(llop2.lo).lsw; op^.token.class := intConstant; end; {else} dispose(op^.left); dispose(op^.right); dispose(op^.middle); op^.left := nil; op^.right := nil; op^.middle := nil; end; {if} end; questionch: begin {error -> ? should not be unmatched} Error(29); errorFound := true; end; barbarop, {||} andandop, {&&} carotch, {^} barch, {|} andch, {&} eqeqop, {==} exceqop, {!=} ltch, {<} gtch, {>} lteqop, {<=} gteqop, {>=} ltltop, {<<} gtgtop, {>>} plusch, {+} minusch, {-} asteriskch, {*} slashch, {/} percentch: begin {%} op^.right := Pop; op^.left := Pop; kindRight := op^.right^.token.kind; kindLeft := op^.left^.token.kind; if kindRight in [intconst,uintconst,ushortconst,longconst,ulongconst, charconst,scharconst,ucharconst] then begin if kindLeft in [intconst,uintconst,ushortconst,longconst,ulongconst, charconst,scharconst,ucharconst] then begin if kind = preprocessorExpression then goto 2; {do the usual binary conversions} if (kindRight = ulongconst) or (kindLeft = ulongconst) then ekind := ulongconst else if (kindRight = longconst) or (kindLeft = longconst) then ekind := longconst else if (kindRight = uintconst) or (kindLeft = uintconst) or (kindRight = ushortconst) or (kindLeft = ushortconst) then ekind := uintconst else ekind := intconst; {evaluate a constant operation} unsigned := ekind in [uintconst,ulongconst]; op1 := IntVal(op^.left^.token); op2 := IntVal(op^.right^.token); dispose(op^.right); op^.right := nil; dispose(op^.left); op^.left := nil; case op^.token.kind of barbarop : begin {||} op1 := ord((op1 <> 0) or (op2 <> 0)); ekind := intconst; end; andandop : begin {&&} op1 := ord((op1 <> 0) and (op2 <> 0)); ekind := intconst; end; carotch : op1 := op1 ! op2; {^} barch : op1 := op1 | op2; {|} andch : op1 := op1 & op2; {&} eqeqop : begin {==} op1 := ord(op1 = op2); ekind := intconst; end; exceqop : begin {!=} op1 := ord(op1 <> op2); ekind := intconst; end; ltch : begin {<} if unsigned then op1 := ult(op1,op2) else op1 := ord(op1 < op2); ekind := intconst; end; gtch : begin {>} if unsigned then op1 := ugt(op1,op2) else op1 := ord(op1 > op2); ekind := intconst; end; lteqop : begin {<=} if unsigned then op1 := ule(op1,op2) else op1 := ord(op1 <= op2); ekind := intconst; end; gteqop : begin {>=} if unsigned then op1 := uge(op1,op2) else op1 := ord(op1 >= op2); ekind := intconst; end; ltltop : begin {<<} op1 := op1 << op2; ekind := kindLeft; end; gtgtop : begin {>>} if kindLeft in [uintconst,ushortconst,ulongconst] then op1 := lshr(op1,op2) else op1 := op1 >> op2; ekind := kindLeft; end; plusch : op1 := op1 + op2; {+} minusch : op1 := op1 - op2; {-} asteriskch : if unsigned then {*} op1 := umul(op1,op2) else op1 := op1 * op2; slashch : begin {/} if op2 = 0 then begin Error(109); op2 := 1; end; {if} if unsigned then op1 := udiv(op1,op2) else op1 := op1 div op2; end; percentch : begin {%} if op2 = 0 then begin Error(109); op2 := 1; end; {if} if unsigned then op1 := umod(op1,op2) else op1 := op1 - (op1 div op2) * op2; end; otherwise: Error(57); end; {case} if ((lint & lintOverflow) <> 0) then begin if op^.token.kind in [plusch,minusch,asteriskch,slashch] then if ekind = intConst then if op1 <> long(op1).lsw then Error(128); if op^.token.kind in [ltltop,gtgtop] then begin if ekind in [intConst,uintConst] then if (op2 < 0) or (op2 > 15) then Error(130); if ekind in [longConst,ulongConst] then if (op2 < 0) or (op2 > 31) then Error(130); end; {if} end; {if} op^.token.kind := ekind; if ekind in [longconst,ulongconst] then begin op^.token.lval := op1; op^.token.class := longConstant; end {if} else begin op^.token.ival := long(op1).lsw; op^.token.class := intConstant; end; {else} goto 1; end; {if} end; {if} 2: if kindRight in [intconst,uintconst,ushortconst,longconst,ulongconst, longlongconst,ulonglongconst,charconst,scharconst,ucharconst] then begin if kindLeft in [intconst,uintconst,ushortconst,longconst,ulongconst, longlongconst,ulonglongconst,charconst,scharconst,ucharconst] then begin if kind = preprocessorExpression then begin kindLeft := PPKind(op^.left^.token); kindRight := PPKind(op^.right^.token); end; {if} {do the usual binary conversions} if (kindRight = ulonglongconst) or (kindLeft = ulonglongconst) then ekind := ulonglongconst else ekind := longlongconst; unsigned := ekind = ulonglongconst; GetLongLongVal(llop1, op^.left^.token); GetLongLongVal(llop2, op^.right^.token); case op^.token.kind of barbarop : begin {||} llop1.lo := ord((llop1.lo <> 0) or (llop1.hi <> 0) or (llop2.lo <> 0) or (llop2.hi <> 0)); llop1.hi := 0; ekind := intconst; end; andandop : begin {&&} llop1.lo := ord(((llop1.lo <> 0) or (llop1.hi <> 0)) and ((llop2.lo <> 0) or (llop2.hi <> 0))); llop1.hi := 0; ekind := intconst; end; carotch : begin {^} llop1.lo := llop1.lo ! llop2.lo; llop1.hi := llop1.hi ! llop2.hi; end; barch : begin {|} llop1.lo := llop1.lo | llop2.lo; llop1.hi := llop1.hi | llop2.hi; end; andch : begin {&} llop1.lo := llop1.lo & llop2.lo; llop1.hi := llop1.hi & llop2.hi; end; eqeqop : begin {==} llop1.lo := ord((llop1.lo = llop2.lo) and (llop1.hi = llop2.hi)); llop1.hi := 0; ekind := intconst; end; exceqop : begin {!=} llop1.lo := ord((llop1.lo <> llop2.lo) or (llop1.hi <> llop2.hi)); llop1.hi := 0; ekind := intconst; end; ltch : begin {<} if unsigned then llop1.lo := ult64(llop1, llop2) else llop1.lo := slt64(llop1, llop2); llop1.hi := 0; ekind := intconst; end; gtch : begin {>} if unsigned then llop1.lo := ugt64(llop1, llop2) else llop1.lo := sgt64(llop1, llop2); llop1.hi := 0; ekind := intconst; end; lteqop : begin {<=} if unsigned then llop1.lo := ule64(llop1, llop2) else llop1.lo := sle64(llop1, llop2); llop1.hi := 0; ekind := intconst; end; gteqop : begin {>=} if unsigned then llop1.lo := uge64(llop1, llop2) else llop1.lo := sge64(llop1, llop2); llop1.hi := 0; ekind := intconst; end; ltltop : begin {<<} shl64(llop1, long(llop2.lo).lsw); ekind := kindLeft; end; gtgtop : begin {>>} if kindleft = ulonglongconst then lshr64(llop1, long(llop2.lo).lsw) else ashr64(llop1, long(llop2.lo).lsw); ekind := kindLeft; end; plusch : add64(llop1, llop2); {+} minusch : sub64(llop1, llop2); {-} asteriskch : umul64(llop1, llop2); {*} slashch : begin {/} if (llop2.lo = 0) and (llop2.hi = 0) then begin Error(109); llop2 := longlong1; end; {if} if unsigned then udiv64(llop1, llop2) else div64(llop1, llop2); end; percentch : begin {%} if (llop2.lo = 0) and (llop2.hi = 0) then begin Error(109); llop2 := longlong1; end; {if} if unsigned then umod64(llop1, llop2) else rem64(llop1, llop2); end; otherwise: Error(57); end; {case} dispose(op^.right); op^.right := nil; dispose(op^.left); op^.left := nil; op^.token.kind := ekind; if ekind in [longlongconst,ulonglongconst] then begin op^.token.qval := llop1; op^.token.class := longlongConstant; end {if} else if ekind in [longconst,ulongconst] then begin op^.token.lval := llop1.lo; op^.token.class := longConstant; end {if} else begin op^.token.ival := long(llop1.lo).lsw; op^.token.class := intConstant; end; {else} goto 1; end; {if} end; {if} if op^.right^.token.kind in [intconst,uintconst,longconst,ulongconst, longlongconst,ulonglongconst,floatconst,doubleconst,extendedconst, compconst,charconst,scharconst,ucharconst,ushortconst] then if op^.left^.token.kind in [intconst,uintconst,longconst,ulongconst, longlongconst,ulonglongconst,floatconst,doubleconst,extendedconst, compconst,charconst,scharconst,ucharconst,ushortconst] then begin if fenvAccess then if kind in [normalExpression, autoInitializerExpression] then goto 1; if (op^.right^.token.kind = compConst) and (op^.left^.token.kind = compConst) then ekind := compconst else if (op^.right^.token.kind in [extendedConst,compConst]) or (op^.left^.token.kind in [extendedConst,compConst]) then ekind := extendedconst else if (op^.right^.token.kind = doubleConst) or (op^.left^.token.kind = doubleConst) then ekind := doubleconst else ekind := floatconst; rop1 := RealVal(op^.left^.token); rop2 := RealVal(op^.right^.token); dispose(op^.right); op^.right := nil; dispose(op^.left); op^.left := nil; case op^.token.kind of barbarop : begin {||} op1 := ord((rop1 <> 0.0) or (rop2 <> 0.0)); ekind := intconst; end; andandop : begin {&&} op1 := ord((rop1 <> 0.0) and (rop2 <> 0.0)); ekind := intconst; end; eqeqop : begin {==} op1 := ord(rop1 = rop2); ekind := intconst; end; exceqop : begin {!=} op1 := ord(rop1 <> rop2); ekind := intconst; end; ltch : begin {<} op1 := ord(rop1 < rop2); ekind := intconst; end; gtch : begin {>} op1 := ord(rop1 > rop2); ekind := intconst; end; lteqop : begin {<=} op1 := ord(rop1 <= rop2); ekind := intconst; end; gteqop : begin {>=} op1 := ord(rop1 >= rop2); ekind := intconst; end; plusch : rop1 := rop1 + rop2; {+} minusch : rop1 := rop1 - rop2; {-} asteriskch : rop1 := rop1 * rop2; {*} slashch : rop1 := rop1 / rop2; {/} otherwise : Error(66); {illegal operation} end; {case} if ekind = intconst then begin op^.token.ival := long(op1).lsw; op^.token.class := intConstant; op^.token.kind := intConst; end {if} else begin op^.token.rval := rop1; op^.token.class := realConstant; op^.token.kind := ekind; end; {else} end; {if} 1: end; plusplusop, {prefix ++} minusminusop, {prefix --} opplusplus, {postfix ++} opminusminus, {postfix --} sizeofsy, {sizeof} _Alignofsy, {_Alignof (erroneous uses)} castoper, {(type)} typedef, {(type-name)} tildech, {~} excch, {!} uminus, {unary -} uplus, {unary +} uand, {unary &} uasterisk: begin {unary *} op^.left := Pop; if op^.token.kind = sizeofsy then begin op^.token.kind := ulongConst; op^.token.class := longConstant; if op^.left^.token.kind = stringConst then op^.token.lval := op^.left^.token.sval^.length else begin lCodeGeneration := codeGeneration; codeGeneration := false; GenerateCode(op^.left); codeGeneration := lCodeGeneration and (numErrors = 0); op^.token.lval := expressionType^.size; with expressionType^ do if (size = 0) or ((kind = arrayType) and (elements = 0)) then Error(49); end; {else} op^.left := nil; end {if sizeofsy} else if op^.token.kind = _Alignofsy then begin {error case: operand of _Alignof is not a parenthesized type-name} Error(36); op^.token.kind := ulongConst; op^.token.class := longConstant; op^.token.lval := 1; dispose(op^.left); end {else if _Alignofsy} else if op^.token.kind = castoper then begin class := op^.left^.token.class; if class in [intConstant,longConstant,longlongconstant, realConstant] then begin tp := op^.castType; while tp^.kind = definedType do tp := tp^.dType; if tp^.kind = scalarType then begin baseType := tp^.baseType; if fenvAccess then if kind in [normalExpression, autoInitializerExpression] then if (baseType in [cgReal,cgDouble,cgComp,cgExtended]) or (class = realConstant) then goto 3; if (baseType < cgString) or (baseType in [cgQuad,cgUQuad]) then begin if class = realConstant then begin rop1 := RealVal(op^.left^.token); if baseType = cgUQuad then CnvXULL(llop1, rop1) else CnvXLL(llop1, rop1); end {if} else begin {handle integer constants} GetLongLongVal(llop1, op^.left^.token); if op^.left^.token.kind = ulonglongconst then rop1 := CnvULLX(llop1) else rop1 := CnvLLX(llop1); end; {else if} dispose(op^.left); op^.left := nil; if baseType in [cgByte,cgWord] then begin if baseType = cgByte then op^.token.kind := scharConst else op^.token.kind := intConst; op^.token.class := intConstant; if tp^.cType = ctBool then op^.token.ival := ord(rop1 <> 0.0) else op^.token.ival := long(llop1.lo).lsw; if baseType = cgByte then with op^.token do begin ival := ival & $00FF; if (ival & $0080) <> 0 then ival := ival | $FF00; end; {with} end {if} else if baseType = cgUWord then begin op^.token.kind := uintConst; op^.token.class := intConstant; op^.token.ival := long(llop1.lo).lsw; end {else if} else if baseType = cgUByte then begin if tp^.cType = ctUChar then op^.token.kind := ucharConst else op^.token.kind := charConst; op^.token.class := intConstant; op^.token.ival := long(llop1.lo).lsw; op^.token.ival := op^.token.ival & $00FF; end {else if} else if baseType = cgLong then begin op^.token.kind := longConst; op^.token.class := longConstant; op^.token.lval := llop1.lo; end {else if} else if baseType = cgULong then begin op^.token.kind := ulongConst; op^.token.class := longConstant; op^.token.lval := llop1.lo; end {else if} else if baseType = cgQuad then begin op^.token.kind := longlongConst; op^.token.class := longlongConstant; op^.token.qval := llop1; end {else if} else if baseType = cgUQuad then begin op^.token.kind := ulonglongConst; op^.token.class := longlongConstant; op^.token.qval := llop1; end {else if} else begin case baseType of cgReal: op^.token.kind := floatConst; cgDouble: op^.token.kind := doubleConst; cgExtended: op^.token.kind := extendedConst; cgComp: op^.token.kind := compConst; end; {case} op^.token.class := realConstant; LimitPrecision(rop1, baseType); op^.token.rval := rop1; end; {else if} end; {if} 3: end; {if} end; {if} end {else if castoper} else if not (op^.token.kind in [typedef,plusplusop,minusminusop,opplusplus,opminusminus,uand]) then begin if (kind <> preprocessorExpression) and (op^.left^.token.kind in [intconst,uintconst,longconst,ulongconst,charconst,scharconst, ucharconst,ushortconst]) then begin {evaluate a constant operation} ekind := op^.left^.token.kind; if ekind in [charconst,scharconst,ucharconst] then ekind := intconst; op1 := IntVal(op^.left^.token); dispose(op^.left); op^.left := nil; case op^.token.kind of tildech : op1 := ~op1; {~} excch : begin {!} op1 := ord(op1 = 0); ekind := intconst; end; uminus : op1 := -op1; {unary -} uplus : ; {unary +} uasterisk : Error(79); {unary *} otherwise: Error(57); end; {case} op^.token.kind := ekind; if ekind in [longconst,ulongconst] then begin op^.token.class := longConstant; op^.token.lval := op1; end {if} else begin op^.token.class := intConstant; op^.token.ival := long(op1).lsw; end; {else} end {if} else if op^.left^.token.kind in [longlongconst,ulonglongconst, intconst,uintconst,longconst,ulongconst,charconst,scharconst, ucharconst,ushortconst] then begin {evaluate a constant operation with long long operand} ekind := op^.left^.token.kind; if ekind in [charconst,scharconst,ucharconst] then ekind := intconst; if kind = preprocessorExpression then ekind := PPKind(op^.left^.token); GetLongLongVal(llop1, op^.left^.token); dispose(op^.left); op^.left := nil; case op^.token.kind of tildech : begin {~} llop1.lo := ~llop1.lo; llop1.hi := ~llop1.hi; end; excch : begin {!} op1 := ord((llop1.hi = 0) and (llop1.lo = 0)); ekind := intconst; end; uminus : begin {unary -} llop1.lo := ~llop1.lo; llop1.hi := ~llop1.hi; llop1.lo := llop1.lo + 1; if llop1.lo = 0 then llop1.hi := llop1.hi + 1; end; uplus : ; {unary +} uasterisk : Error(79); {unary *} otherwise: Error(57); end; {case} op^.token.kind := ekind; if ekind in [longlongconst,ulonglongconst] then begin op^.token.class := longlongConstant; op^.token.qval := llop1; end {if} else begin op^.token.class := intConstant; op^.token.ival := long(op1).lsw; end; {else} end {else if} else if op^.left^.token.kind in [floatconst,doubleconst,extendedconst,compconst] then begin if fenvAccess then if kind in [normalExpression, autoInitializerExpression] then goto 4; ekind := op^.left^.token.kind; rop1 := RealVal(op^.left^.token); dispose(op^.left); op^.left := nil; case op^.token.kind of uminus : begin {unary -} op^.token.class := realConstant; op^.token.kind := ekind; op^.token.rval := -rop1; end; uplus : begin {unary +} op^.token.class := realConstant; op^.token.kind := ekind; op^.token.rval := rop1; end; excch : begin {!} op^.token.class := intConstant; op^.token.kind := intconst; op^.token.ival := ord(rop1 = 0.0); end; otherwise : begin {illegal operation} Error(66); op^.token.class := realConstant; op^.token.kind := ekind; op^.token.rval := rop1; end; end; {case} end; {if} end; {if} 4: end; otherwise: Error(57); end; {case} op^.next := stack; {place the operation on the operand stack} stack := op; end; {Operation} procedure Skip; { skip all tokens in the remainder of the expression } begin {Skip} while not (token.kind in stopSym+[eofsy]) do NextToken; errorFound := true; end; {Skip} procedure DoGeneric; { process a generic selection expression } label 10; type typeListPtr = ^typeList; typeList = record next: typeListPtr; theType: typePtr; end; var lCodeGeneration: boolean; {local copy of codeGeneration} tempExpr: tokenPtr; {temporary to hold expression trees} controllingType: typeRecord; {type of controlling expression} typesSeen: typeListPtr; {types that already have associations} tl: typeListPtr; {temporary type list pointer} resultExpr: tokenPtr; {the result expression} defaultExpr: tokenPtr; {the default expression} currentType: typePtr; {the type for the current association} typesMatch: boolean; {does the current type match} foundMatch: boolean; {have we found a matching type?} foundDefault: boolean; {have we found the default case?} begin {DoGeneric} if not expectingTerm then begin Error(36); Skip; goto 1; end; {if} NextToken; if token.kind <> lparench then begin Error(36); Skip; goto 1; end; {if} new(op); {record it like a parenthesized expr} op^.next := opStack; op^.left := nil; op^.middle := nil; op^.right := nil; opStack := op; op^.token.kind := lparench; op^.token.class := reservedSymbol; parenCount := parenCount+1; NextToken; {process the controlling expression} tempExpr := ExpressionTree(normalExpression, [commach]); lCodeGeneration := codeGeneration; codeGeneration := false; GenerateCode(tempExpr); codeGeneration := lCodeGeneration and (numErrors = 0); {get controlling type after conversions} if expressionType^.kind = functionType then begin controllingType.size := cgPointerSize; controllingType.kind := pointerType; controllingType.pType := expressionType; end {if} else if expressionType^.kind in [structType,unionType] then begin controllingType.size := expressionType^.size; controllingType.kind := definedType; controllingType.dType := expressionType; end {else if} else controllingType := expressionType^; if controllingType.kind = arrayType then begin controllingType.kind := pointerType; controllingType.size := cgPointerSize; end; {if} controllingType.qualifiers := []; controllingType.saveDisp := 0; typesSeen := nil; resultExpr := nil; defaultExpr := nil; foundMatch := false; foundDefault := false; while token.kind = commach do begin {process the generic associations} NextToken; typesMatch := false; if token.kind <> defaultsy then begin if not (token.kind in specifierQualifierListElement) then begin Error(26); while not (token.kind in [colonch,commach,rparench,eofsy]) do NextToken; end; {if} currentType := TypeName; {get the type name} if (currentType^.size = 0) or (currentType^.kind = functionType) then Error(133); tl := typesSeen; {check if it is a duplicate} while tl <> nil do begin if StrictCompTypes(currentType, tl^.theType) then begin Error(158); goto 10; end; {if} tl := tl^.next; end; {while} new(tl); {record it as seen} tl^.next := typesSeen; tl^.theType := currentType; typesSeen := tl; {see if the types match} typesMatch := StrictCompTypes(currentType, controllingType); if typesMatch then begin if foundMatch then begin {sanity check - should never happen} typesMatch := false; Error(158); end; {if} foundMatch := true; end; {if} end {if} else begin {handle default association} NextToken; currentType := nil; if foundDefault then Error(159); foundDefault := true; end; {else} 10: if token.kind = colonch then {skip the colon} NextToken else Error(29); {get the expression in this association} if (currentType = nil) and (defaultExpr = nil) and not foundMatch then defaultExpr := ExpressionTree(kind, [commach,rparench]) else if typesMatch then resultExpr := ExpressionTree(kind, [commach,rparench]) else tempExpr := ExpressionTree(normalExpression, [commach,rparench]); end; {while} if token.kind <> rparench then Error(12); while typesSeen <> nil do begin {dispose of the list of types seen} tl := typesSeen^.next; dispose(typesSeen); typesSeen := tl; end; {while} if not foundMatch then {use default if no match found} if foundDefault then resultExpr := defaultExpr; if not (foundMatch or foundDefault) then begin Error(160); {report error & synthesize a token} resultExpr := pointer(Calloc(sizeof(tokenRecord))); resultExpr^.token.kind := intconst; resultExpr^.token.class := intConstant; {resultExpr^.token.ival := 0;} end; {if} if resultExpr <> nil then begin resultExpr^.next := stack; {stack the resulting expression} stack := resultExpr; end; {if} expectingTerm := false; end; {DoGeneric} procedure DoCompoundLiteral; { process a compound literal expression } label 1; var id: identPtr; sp: tokenPtr; begin {DoCompoundLiteral} if kind in [preprocessorExpression,arrayExpression] then begin op := opStack; while op <> nil do begin if op^.token.kind = sizeofsy then goto 1; op := op^.next; end; {while} Error(41); errorFound := true; end; {if} 1: id := MakeCompoundLiteral(opStack^.castType); opStack := opStack^.next; {create an operand on the stack} new(sp); if id^.class = staticsy then sp^.token.kind := ident else sp^.token.kind := compoundliteral; sp^.token.class := identifier; sp^.token.symbolPtr := id; sp^.token.name := id^.name; sp^.id := id; sp^.next := stack; sp^.left := nil; sp^.middle := nil; sp^.right := nil; stack := sp; ComplexTerm; expectingTerm := false; end; {DoCompoundLiteral} begin {ExpressionTree} opStack := nil; stack := nil; if token.kind = typedef then {handle typedefs that are hidden} if FindSymbol(token,allSpaces,false,true) <> nil then if token.symbolPtr^.class <> typedefsy then token.kind := ident; if token.kind in startExpression then begin expressionValue := 0; {initialize the expression value} expectingTerm := true; {the first item should be a term} done := false; {convert the expression to postfix form} parenCount := 0; repeat {scan the token list...} if token.kind in startTerm then begin {we must expect a term or unary operand} if not expectingTerm then begin Error(36); Skip; goto 1; end; {if} if token.kind = ident then {handle a complex operand} DoOperand else begin {handle a constant operand} new(sp); sp^.token := token; sp^.next := stack; sp^.left := nil; sp^.middle := nil; sp^.right := nil; stack := sp; if kind in [preprocessorExpression,arrayExpression] then if token.kind in [stringconst,floatconst,doubleconst, extendedconst,compconst] then begin if kind = arrayExpression then begin op := opStack; if token.kind <> stringconst then if op <> nil then if op^.token.kind = castoper then if op^.casttype^.kind = scalarType then if op^.casttype^.baseType in [cgByte,cgUByte, cgWord,cgUWord,cgLong,cgULong,cgQuad,cgUQuad] then goto 3; while op <> nil do begin if op^.token.kind = sizeofsy then goto 3; op := op^.next; end; {while} end; {if} Error(41); errorFound := true; end; {if} 3: NextToken; ComplexTerm; end; {else} expectingTerm := false; {the next thing should be an operation} end {else} {handle a closing parenthesis} else if (token.kind = rparench) and (parenCount > 0) then begin if expectingTerm then begin {make sure it is in a legal spot} Error(37); Skip; goto 1; end; {if} while opStack^.token.kind <> lparench do Operation; {do pending operations} op := opStack; opStack := op^.next; dispose(op); parenCount := parenCount-1; NextToken; {skip the ')'} ComplexTerm; {handle subscripts, selection, etc.} end {else} else if token.kind = lparench then begin {handle open paren and type casts} if not expectingTerm then begin Error(38); Skip; goto 1; end; {if} NextToken; if token.kind in specifierQualifierListElement then begin doingSizeof := false; doingAlignof := false; if opStack <> nil then if opStack^.token.kind = sizeofsy then doingSizeof := true else if opStack^.token.kind = _Alignofsy then doingAlignof := true; tType := TypeName; if doingSizeof or doingAlignof then begin {handle a sizeof operator} op := opStack; opStack := op^.next; dispose(op); new(sp); sp^.next := stack; sp^.left := nil; sp^.middle := nil; sp^.right := nil; sp^.token.kind := ulongconst; sp^.token.class := longConstant; if doingSizeof then sp^.token.lval := tType^.size else {if doingAlignof then} sp^.token.lval := 1; with tType^ do if (size = 0) or ((kind = arrayType) and (elements = 0)) then Error(133); sp^.next := stack; stack := sp; expectingTerm := false; end {if} else {doing a cast} begin {handle a type cast} new(op); {stack the cast operator} op^.left := nil; op^.middle := nil; op^.right := nil; op^.castType := tType; op^.token.kind := castoper; op^.token.class := reservedWord; op^.next := opStack; opStack := op; end; {else} Match(rparench,12); end {if} else begin new(op); {record the '('} op^.next := opStack; op^.left := nil; op^.middle := nil; op^.right := nil; opStack := op; op^.token.kind := lparench; op^.token.class := reservedSymbol; parenCount := parenCount+1; end; end {else if} else if (token.kind = lbracech) {handle a compound literal} and (opstack <> nil) and (opStack^.token.kind = castoper) then begin DoCompoundLiteral end {else if} else if token.kind = _Genericsy then {handle _Generic} DoGeneric else begin {handle an operation...} if expectingTerm then {convert unary operators to separate tokens} if token.kind in [asteriskch,minusch,plusch,andch] then case token.kind of asteriskch: token.kind := uasterisk; minusch : token.kind := uminus; andch : token.kind := uand; plusch : token.kind := uplus; otherwise : Error(57); end; {case} if icp[token.kind] = notAnOperation then done := true {end of expression found...} else if (token.kind in stopSym) and (parenCount = 0) and ((opStack = nil) or (opStack^.token.kind <> questionch)) then done := true else begin if not (kind in [normalExpression, autoInitializerExpression]) then if (token.kind in [plusplusop,minusminusop,eqch,pluseqop,minuseqop, opplusplus,opminusminus, asteriskeqop,slasheqop,percenteqop,ltlteqop, gtgteqop,caroteqop,bareqop,commach]) or ((kind = preprocessorExpression) and (token.kind = sizeofsy)) or ((kind <> initializerExpression) and (token.kind = uand)) then begin Error(161); errorFound := true; end; {if} if token.kind in {make sure we get what we want} [plusplusop,minusminusop,sizeofsy,_Alignofsy,tildech,excch, uasterisk,uminus,uplus,uand] then begin if not expectingTerm then begin Error(38); Skip; goto 1; end; {if} end {if} else begin if expectingTerm then begin Error(37); Skip; goto 1; end; {if} expectingTerm := true; {handle 2nd half of ternary operator} if token.kind = colonch then begin done2 := false; {do pending operations} repeat if opStack = nil then done2 := true else if opStack^.token.kind <> questionch then Operation else done2 := true; until done2; if (opStack = nil) or (opStack^.token.kind <> questionch) then begin Error(39); Skip; goto 1; end; {if} op := opStack; opStack := op^.next; dispose(op); end {if} else begin done2 := false; {do operations with less precedence} repeat if opStack = nil then done2 := true else if isp[opStack^.token.kind] >= icp[token.kind] then Operation else done2 := true; until done2; end; {else} end; {else} new(op); {record the operation} op^.next := opStack; op^.left := nil; op^.middle := nil; op^.right := nil; opStack := op; op^.token := token; NextToken; end; {else} end; {else} 2: until done; if parenCount > 0 then begin Error(12); errorFound := true; end {if} else begin while opStack <> nil do {do pending operations} Operation; {there should be exactly one operand left} if (stack = nil) or (stack^.next <> nil) then begin Error(36); errorFound := true; end; {if} end; {else} end {if} else begin {the start of an expression was not found} Error(35); if not (token.kind in stopSym) then NextToken; Skip; end; {else} 1: if errorFound then begin while opStack <> nil do begin op := opStack; opStack := op^.next; dispose(op); end; {while} while stack <> nil do begin sp := stack; stack := sp^.next; DisposeTree(sp); end; {while} ExpressionTree := nil; end {if} else ExpressionTree := stack; end; {ExpressionTree} procedure CompareToZero {op: pcodes}; { Compare the result on tos to zero. } { } { This procedure is used by the logical statements to compare } { _any_ scalar result to zero, giving a boolean result. } { } { parameters: } { op - operation to use on the compare } var bt: baseTypeEnum; {base type of loaded value} begin {CompareToZero} if expressionType^.kind in [pointerType,arrayType] then expressionType := uLongPtr; if expressionType^.kind = scalarType then begin bt := UsualUnaryConversions; case bt of cgByte,cgUByte,cgWord,cgUWord: Gen1t(pc_ldc, 0, cgWord); cgLong,cgULong: GenLdcLong(0); cgQuad,cgUQuad: GenLdcQuad(longlong0); cgReal,cgDouble,cgComp,cgExtended: GenLdcReal(0.0); otherwise: Error(47); end; {case} expressionType := intPtr; Gen0t(op, bt); end {if} else Error(47); end; {CompareToZero} procedure FreeTemp{labelNum, size: integer}; { place a temporary label in the available label list } { } { parameters: } { labelNum - number of the label to free } { size - size of the variable } { } { variables: } { tempList - list of free labels } var tl: tempPtr; {work pointer} begin {FreeTemp} new(tl); tl^.next := tempList; tl^.last := nil; tl^.labelNum := labelNum; tl^.size := size; if tempList <> nil then tempList^.last := tl; tempList := tl; end; {FreeTemp} function GetTemp{size: integer): integer}; { find a temporary work variable } { } { parameters: } { size - size of the variable } { } { variables: } { tempList - list of free labels } { } { Returns the label number. } label 1; var lcodeGeneration: boolean; {local copy of codeGeneration} ln: integer; {label number} tl: tempPtr; {work pointer} begin {GetTemp} {try to find a temp from the existing list} tl := tempList; while tl <> nil do begin if tl^.size = size then begin {found an old one - use it} if tl^.last = nil then tempList := tl^.next else tl^.last^.next := tl^.next; if tl^.next <> nil then tl^.next^.last := tl^.last; GetTemp := tl^.labelNum; goto 1; end; {if} tl := tl^.next; end; {while} {none found - get a new one} ln := GetLocalLabel; GetTemp := ln; lcodeGeneration := codeGeneration; codeGeneration := true; Gen2(dc_loc, ln, size); codeGeneration := lCodeGeneration and (numErrors = 0); 1: end; {GetTemp} procedure LoadScalar (id: identPtr); { Load a scalar value. } { } { parameters: } { id - ident for value to load } var tp: baseTypeEnum; {base type} begin {LoadScalar} if id^.itype^.kind = scalarType then tp := id^.itype^.baseType else {if id^.itype^.kind in [pointerType,arrayType] then} tp := cgULong; case id^.storage of stackFrame, parameter: Gen2t(pc_lod, id^.lln, 0, tp); external, global, private: Gen1tName(pc_ldo, 0, tp, id^.name); otherwise: ; end; {case} end; {LoadScalar} procedure Cast(tp: typePtr); { Cast the current expression to the stated type } { } { parameters: } { tp - type to cast to } { } { inputs: } { expressionType - type of the expression to cast } { } { outputs: } { expressionType - set to result type } var et,rt: baseTypeEnum; {work variables} begin {Cast} if (tp^.kind = scalarType) and (tp^.cType = ctBool) then begin CompareToZero(pc_neq); end {if} else if (tp^.kind = scalarType) and (expressionType^.kind = scalarType) then begin rt := tp^.baseType; et := expressionType^.baseType; if (rt <> et) or (rt in [cgReal,cgDouble,cgComp]) then if et <> cgVoid then Gen2(pc_cnv, ord(et), ord(rt)) else Error(40); end {if} else if (tp^.kind = enumType) and (expressionType^.kind = scalarType) then begin if expressionType^.baseType <> cgVoid then begin rt := cgWord; et := Unary(expressionType^.baseType); if rt <> et then Gen2(pc_cnv, ord(et), ord(rt)); end {if} else Error(40); end {if} else if (tp^.kind = scalarType) and (expressionType^.kind = enumType) then begin rt := Unary(tp^.baseType); et := cgWord; if rt <> et then Gen2(pc_cnv, ord(et), ord(rt)); end {if} else if tp^.kind = pointerType then begin case expressionType^.kind of scalarType: if expressionType^.baseType in [cgByte,cgUByte,cgWord,cgUWord,cgLong,cgULong,cgQuad,cgUQuad] then Gen2(pc_cnv, ord(Unary(expressionType^.baseType)), ord(cgULong)) else if doDispose then Error(40); arrayType,pointerType: ; functionType,enumConst,enumType,definedType,structType,unionType: if doDispose then Error(40); otherwise: Error(57); end; {case} end {else if} else if expressionType^.kind in [pointerType,arrayType] then begin case tp^.kind of scalarType: if tp^.baseType in [cgByte,cgUByte,cgWord,cgUWord,cgLong,cgULong,cgQuad,cgUQuad] then Gen2(pc_cnv, ord(cgULong), ord(Unary(tp^.baseType))) else if tp^.baseType = cgVoid then Gen0t(pc_pop, UsualUnaryConversions) else Error(40); otherwise: Error(40); end; {case} end {else if} else if expressionType^.kind in [structType,unionType] then begin if tp^.kind = scalarType then if tp^.baseType = cgVoid then Gen0t(pc_pop, UsualUnaryConversions) else Error(40) else Error(40); end {else if} else Error(40); expressionType := tp; end; {Cast} procedure DoSelection {lType: typePtr; tree: tokenPtr; var size: longint}; { Find the displacement & type for a selection operation } { } { parameters: } { lType - structure/union type } { tree - right-hand tree } { size - disp into the structure/union } { } { returned in non-local variables: } { bitDisp - displacement to bit field } { bitSize - size of bit field } { unsigned - is the bit field unsigned? } { isBitField - is the field a bit field? } { } { variables: } { expressionType - set to the type of the field } label 1; var ip: identPtr; {for scanning for the field} qualifiers: typeQualifierSet; {type qualifiers} begin {DoSelection} expressionType := intPtr; {set defaults in case there is an error} size := 0; if tree^.token.class = identifier then begin qualifiers := lType^.qualifiers; while lType^.kind = definedType do begin lType := lType^.dType; qualifiers := qualifiers + lType^.qualifiers; end; {while} if lType^.kind in [structType,unionType] then begin ip := lType^.fieldList; {find a matching field} while ip <> nil do begin if ip^.name^ = tree^.token.name^ then begin if ip^.isForwardDeclared then ResolveForwardReference(ip); size := ip^.disp; {match found - record parameters} expressionType := MakeQualifiedType(ip^.itype, qualifiers); bitDisp := ip^.bitDisp; bitSize := ip^.bitSize; isBitField := (bitSize+bitDisp) <> 0; unsigned := (ip^.itype^.baseType in [cgUByte,cgUWord,cgULong]) or (ip^.itype^.cType = ctBool); goto 1; end; {if} ip := ip^.next; end; {while} Error(81); end {if} else Error(80); end; {if} 1: end; {DoSelection} procedure L_Value(tree: tokenPtr); { Check for an l-value } { } { parameters: } { tree - expression tree to check } var kind: tokenEnum; {for efficiency} begin {L_Value} kind := tree^.token.kind; {A variable identifier is an l-value unless it is a function or } {non-parameter array } if kind in [ident,compoundliteral] then begin if tree^.id^.itype^.kind = arrayType then begin if tree^.id^.storage <> parameter then if doDispose then {prevent spurious errors} Error(78); end {if} else if tree^.id^.itype^.kind in [functionType,enumConst,enumType] then if doDispose then {prevent spurious errors} Error(78); end {if} {e.field is an l-value if and only if e is an l-value} else if kind = dotch then L_Value(tree^.left) {Bypass cast operators } {following test removed to flag bug for: } { int *p; long l; } { (long) p = l; } {else if kind = castoper then L_Value(tree^.left)} {The result of an array subscript (a[i]), indirect selection, } {or the indirection operator all show up as the uasterisk } {operator at this point. All are l-values, but nothing else } {not already allowed is an l-value. } else if kind <> uasterisk then if doDispose then {prevent spurious errors} Error(78); end; {L_Value} procedure ChangePointer (op: pcodes; size: longint; tp: baseTypeEnum); { Add or subtract an integer to a pointer } { } { The stack has a pointer and an integer (integer on TOS). } { The integer is removed, multiplied by size, and either } { added to or subtracted from the pointer; the result } { replaces the pointer on the stack } { } { parameters: } { op - operation (pc_adl or pc_sbl) } { size - size of one pointer element } { tp - type of the integer operand } begin {ChangePointer} if size = 0 then Error(122); case tp of cgByte,cgUByte,cgWord,cgUWord: begin if (size = long(size).lsw) and (op = pc_adl) and smallMemoryModel and (tp in [cgUByte,cgUWord]) then begin if size <> 1 then begin Gen1t(pc_ldc, long(size).lsw, cgWord); Gen0(pc_umi); end; {if} Gen0t(pc_ixa, cgUWord); end {if} else if smallMemoryModel and (size = long(size).lsw) then begin if size <> 1 then begin Gen1t(pc_ldc, long(size).lsw, cgWord); Gen0(pc_umi); end; {if} Gen2(pc_cnv, ord(tp), ord(cgLong)); Gen0(op); end {else if} else begin Gen2(pc_cnv, ord(tp), ord(cgLong)); if size <> 1 then begin GenLdcLong(size); Gen0(pc_mpl); end; {if} Gen0(op); end; end; cgLong,cgULong,cgQuad,cgUQuad: begin if tp in [cgQuad,cgUQuad] then Gen2(pc_cnv, ord(tp), ord(cgLong)); if size <> 1 then begin GenLdcLong(size); if tp in [cgLong,cgQuad] then Gen0(pc_mpl) else Gen0(pc_uml); end; {if} Gen0(op); end; otherwise: Error(66); end; {case} end; {ChangePointer} procedure GenerateCode {tree: tokenPtr}; { generate code from a fully formed expression tree } { } { parameters: } { tree - top of the expression tree to generate code from } { } { variables: } { expressionType - result type of the expression } var doingScalar: boolean; {temp; for assignment operators} et: baseTypeEnum; {temp storage for a base type} i: integer; {loop variable} isNullPtrConst: boolean; {is this a null pointer constant?} isVolatile: boolean; {is this a volatile op?} lType: typePtr; {type of operands} kind: typeKind; {temp type kind} size: longint; {size of an array element} t1: integer; {temporary work space label number} tlastwasconst: boolean; {temp lastwasconst} tlastconst: longint; {temp lastconst} tlastWasNullPtrConst: boolean; {temp lastWasNullPtrConst} tp: tokenPtr; {work pointer} tType: typePtr; {temp type of operand} lbitDisp,lbitSize: integer; {for temp storage} lisBitField: boolean; ldoDispose: boolean; {local copy of doDispose} function ExpressionKind (tree: tokenPtr): typeKind; { returns the type of an expression } { } { This subroutine is used to see if + and - operations } { should do pointer addition. } { } { parameters: } { tree - top of the expression tree to check } var ldoDispose: boolean; {local copy of doDispose} lcodeGeneration: boolean; {local copy of codeGeneration} lexpressionType: typePtr; {local copy of expressionType} begin {ExpressionKind} ldoDispose := doDispose; {inhibit disposing of the tree} doDispose := false; lcodeGeneration := codeGeneration; {inhibit code generation} codeGeneration := false; lexpressionType := expressionType; {save the expression type} GenerateCode(tree); {get the type} while expressionType^.kind = definedType do expressionType := expressionType^.dType; ExpressionKind := expressionType^.kind; doDispose := ldoDispose; {restore the volatile variables} codeGeneration := lCodeGeneration and (numErrors = 0); expressionType := lexpressionType; end; {ExpressionKind} procedure LoadAddress (tree: tokenPtr); { load the address of an l-value } { } { parameters: } { tree - top of the expression tree to load the } { address of } { } { variables: } { expressionType - result type of the expression } { isBitField - this variable is set to false so that } { it can be used to see if DoSelection was called } { and located a bit field } label 1; var eType: typePtr; {work pointer} i: integer; {loop variable} size: longint; {disp in record} tname: stringPtr; {temp name pointer} begin {LoadAddress} isBitField := false; if tree^.token.kind = ident then begin {load the address of an identifier} with tree^.id^ do begin tname := name; if itype^.kind = functionType then begin if itype^.isPascal then begin tname := pointer(Malloc(length(name^)+1)); CopyString(pointer(tname), pointer(name)); for i := 1 to length(tname^) do if tname^[i] in ['a'..'z'] then tname^[i] := chr(ord(tname^[i]) & $5F); end; {if} end; {if} case storage of stackFrame: Gen2(pc_lda, lln, 0); parameter: if itype^.kind = arrayType then Gen2t(pc_lod, pln, 0, cgULong) else Gen2(pc_lda, pln, 0); external, global, private: Gen1Name(pc_lao, 0, tname); otherwise: ; end; {case} expressionType := MakePointerTo(iType); end; {with} end {if} else if tree^.token.kind = compoundliteral then begin {evaluate a compound literal and load its address} AutoInit(tree^.id, 0, true); tree^.token.kind := ident; LoadAddress(tree); tree^.token.kind := compoundliteral; Gen0t(pc_bno, cgULong); end {if} else if tree^.token.kind = uasterisk then begin {load the address of the item pointed to by the pointer} GenerateCode(tree^.left); isBitField := false; if not (expressionType^.kind in [pointerType,arrayType,functionType]) then Error(79); end {else if} else if tree^.token.kind = dotch then begin {load the address of a field of a record} LoadAddress(tree^.left); eType := expressionType; if eType^.kind in [arrayType,pointerType] then begin if eType^.kind = arrayType then eType := eType^.aType else if eType^.kind = pointerType then eType := eType^.pType; DoSelection(eType, tree^.right, size); if size <> 0 then if size & $00007FFF = size then Gen1t(pc_inc, long(size).lsw, cgULong) else begin GenLdcLong(size); Gen0(pc_adl); end; {else} expressionType := MakePointerTo(expressionType); end {if} else Error(79); end {else if} else if tree^.token.kind = castoper then begin {load the address of a field of a record} LoadAddress(tree^.left); expressionType := tree^.castType; if expressionType^.kind <> arrayType then expressionType := MakePointerTo(expressionType); end {else if} else if ExpressionKind(tree) in [arrayType,pointerType,structType,unionType] then GenerateCode(tree) else begin expressionType := intPtr; {set default type in case of error} if doDispose then {prevent spurious errors} Error(78); end; {else} 1: end; {LoadAddress} procedure DoIncDec (tree: tokenPtr; pc_l, pc_g, pc_i: pcodes); { do ++ and -- } { } { parameters: } { tree - tree to generate the instruction for } { pc_l - op code for a local ++ or -- } { pc_g - op code for a global ++ or -- } { pc_i - op code for an indirect ++ or -- } label 1; var baseType: baseTypeEnum; {type of operation} lSize: longint; {number to inc or dec by} iSize: integer; {number to inc or dec by} tp: baseTypeEnum; {type of operand} procedure IncOrDec (inc: boolean); { Increment or decrement a number on TOS } { } { parameters: } { inc - increment the number? } begin {IncOrDec} case expressionType^.kind of scalarType: case tp of cgByte,cgUByte,cgWord,cgUWord: begin Gen1t(pc_ldc, 1, cgWord); if inc then Gen0(pc_adi) else Gen0(pc_sbi); if expressionType^.cType = ctBool then begin CompareToZero(pc_neq); expressionType := boolPtr; end {if} end; cgLong,cgULong: begin GenLdcLong(1); if inc then Gen0(pc_adl) else Gen0(pc_sbl); end; cgQuad,cgUQuad: begin GenLdcQuad(longlong1); if inc then Gen0(pc_adq) else Gen0(pc_sbq); end; cgReal,cgDouble,cgComp,cgExtended: begin GenLdcReal(1.0); if inc then Gen0(pc_adr) else Gen0(pc_sbr); end; otherwise: Error(57); end; {case} pointerType,arrayType: begin GenldcLong(expressionType^.pType^.size); if inc then Gen0(pc_adl) else Gen0(pc_sbl); end; otherwise: ; end; {case} end; {IncOrDec} begin {DoIncDec} L_Value(tree); if (tree^.token.kind = ident) and ((tree^.id^.iType^.kind in [scalarType,pointerType]) or ((tree^.id^.iType^.kind = arrayType) and (tree^.id^.storage = parameter))) then with tree^.id^ do begin {check for ++ or -- of a constant} if tqConst in iType^.qualifiers then Error(93); {do an efficient ++ or -- on a named location} if iType^.kind = scalarType then begin iSize := 1; baseType := iType^.baseType; if (baseType in [cgReal,cgDouble,cgComp,cgExtended,cgQuad,cgUQuad]) or (iType^.cType = ctBool) then begin {do real or bool inc or dec} LoadScalar(tree^.id); {load the value} if pc_l in [pc_lli,pc_lld] then if iType^.cType in [ctBool,ctFloat,ctDouble,ctLongDouble, ctComp] then begin t1 := GetTemp(ord(iType^.size)); Gen2t(pc_cop, t1, 0, iType^.baseType); end; {if} tp := baseType; expressionType := iType; IncOrDec(pc_l in [pc_lli,pc_lil]); {do the ++ or --} case storage of {save the result} stackFrame, parameter: Gen2t(pc_cop, lln, 0, baseType); external, global, private: Gen1tName(pc_cpo, 0, baseType, name); otherwise: ; end; {case} {correct the value for postfix ops} if pc_l in [pc_lli,pc_lld] then if iType^.cType in [ctBool,ctFloat,ctDouble,ctLongDouble, ctComp] then begin Gen0t(pc_pop, iType^.baseType); Gen2t(pc_lod, t1, 0, iType^.baseType); Gen0t(pc_bno, iType^.baseType); FreeTemp(t1, ord(iType^.size)); end {if} else IncOrDec(pc_l = pc_lld); if iType^.cType = ctBool then expressionType := boolPtr else if baseType = cgQuad then expressionType := longLongPtr else if baseType = cgUQuad then expressionType := ulongLongPtr else expressionType := doublePtr; goto 1; end {if} else if baseType = cgVoid then Error(65); end {if} else {if iType^.kind in [pointerType,arrayType] then} begin lSize := iType^.pType^.size; if lSize = 0 then Error(122); if long(lSize).msw <> 0 then begin {handle inc/dec of >64K} LoadScalar(tree^.id); GenLdcLong(lSize); if pc_l in [pc_lli,pc_lil] then Gen0(pc_adl) else Gen0(pc_sbl); with tree^.id^ do case storage of stackFrame, parameter: Gen2t(pc_cop, lln, 0, cgULong); external, global, private: Gen1tName(pc_cpo, 0, cgULong, name); otherwise: ; end; {case} if pc_l in [pc_lli,pc_lld] then begin GenLdcLong(lSize); if pc_l = pc_lld then Gen0(pc_adl) else Gen0(pc_sbl); end; {if} goto 1; end; {if} baseType := cgULong; iSize := long(lSize).lsw; end; {else} case storage of stackFrame, parameter: Gen2t(pc_l, lln, iSize, baseType); external, global, private: Gen2tName(pc_g, iSize, 0, baseType, name); otherwise: ; end; {case} expressionType := itype; end {with} else begin {do an indirect ++ or --} LoadAddress(tree); {get the address to save to} if expressionType^.kind = arrayType then expressionType := expressionType^.aType else if expressionType^.kind = pointerType then expressionType := expressionType^.pType; if tqConst in expressionType^.qualifiers then Error(93); if expressionType^.kind = scalarType then if expressionType^.baseType in [cgByte,cgUByte,cgWord,cgUWord,cgReal,cgDouble,cgComp,cgExtended] then tp := expressionType^.baseType else tp := UsualUnaryConversions else begin if expressionType^.kind in [structType,unionType,definedType] then Error(66); tp := UsualUnaryConversions; end; {else} if (tp in [cgByte,cgUByte,cgWord,cgUword]) and (expressionType^.cType <> ctBool) and not isBitField then Gen0t(pc_i, tp) {do indirect inc/dec} else if tp = cgVoid then Error(65) else begin t1 := GetTemp(cgLongSize); Gen2t(pc_str, t1, 0, cgULong); Gen2t(pc_lod, t1, 0, cgULong); Gen2t(pc_lod, t1, 0, cgULong); FreeTemp(t1, cgLongSize); {load the value} if isBitField then begin if unsigned then Gen2t(pc_lbu, bitDisp, bitSize, tp) else Gen2t(pc_lbf, bitDisp, bitSize, tp); end {if} else Gen2t(pc_ind, ord(tqVolatile in expressionType^.qualifiers), 0, tp); if pc_l in [pc_lli,pc_lld] then if expressionType^.cType in [ctBool,ctFloat,ctDouble,ctLongDouble, ctComp] then begin t1 := GetTemp(ord(expressionType^.size)); Gen2t(pc_cop, t1, 0, expressionType^.baseType); end; {if} IncOrDec(pc_l in [pc_lli,pc_lil]); {do the ++ or --} if isBitField then {copy the value} Gen2t(pc_cbf, bitDisp, bitSize, tp) else Gen0t(pc_cpi, tp); Gen0t(pc_bno, tp); if pc_l in [pc_lli,pc_lld] then {correct the value for postfix ops} if expressionType^.cType in [ctBool,ctFloat,ctDouble,ctLongDouble, ctComp] then begin Gen0t(pc_pop, expressionType^.baseType); Gen2t(pc_lod, t1, 0, expressionType^.baseType); Gen0t(pc_bno, expressionType^.baseType); FreeTemp(t1, ord(expressionType^.size)); end {if} else IncOrDec(pc_l = pc_lld); end; {else} end; {else} 1: end; {DoIncDec} procedure FunctionCall (tree: tokenPtr); { generate the actual function call } var fName: stringPtr; {uppercase file name} fntype: typePtr; {temp function type} ftree: tokenPtr; {function address tree} ftype: typePtr; {function type} hasVarargs: boolean; {varargs call with 1+ varargs passed?} i: integer; {loop variable} indirect: boolean; {is this an indirect call?} ldoDispose: boolean; {local copy of doDispose} lcodeGeneration: boolean; {local copy of codeGeneration} procedure FunctionParms (parms: tokenPtr; fType: typePtr); { Generate a function call. } { } { parameters: } { parms - parameter list } { fType - function type } var kind: typeKind; {for expression kinds} ldoDispose: boolean; {local copy of doDispose} lnumErrors: integer; {number of errors before type check} numParms: integer; {# of parameters generated} parameters: parameterPtr; {next prototyped parameter} pCount: integer; {# of parameters prototyped} prototype: boolean; {is the function prototyped?} tp: tokenPtr; {work pointers} fp, tfp: fmtArgPtr; fmt: fmt_type; procedure Reverse; { Reverse the parameter list } var p1,p2,p3: tokenPtr; {work pointers} begin {Reverse} p3 := parms; {remove the last entry} p1 := parms; p2 := nil; while p3^.right <> nil do begin p2 := p3; p3 := p3^.right; end; {while} if p2 <> nil then p2^.right := nil else p1 := nil; while p1 <> nil do begin {reverse the remaining parms} p2 := p1; p1 := p1^.right; p2^.right := p3; p3 := p2; end; {while} parms := p3; end; {Reverse} begin {FunctionParms} {check the validity of the parameter list} if ftype^.isPascal then {reverse parms for pascal calls} Reverse; tp := parms; {set up to check types} prototype := ftype^.prototyped; parameters := ftype^.parameterList; pCount := 1; fmt := fmt_none; fp := nil; if ((lint & lintPrintf) <> 0) and fType^.varargs and not indirect then fmt := FormatClassify(ftree^.id^.name^); while parameters <> nil do begin {count the prototypes} pCount := pCount+1; parameters := parameters^.next; end; {while} parameters := ftype^.parameterList; if prototype then begin {check for wrong # of parms} while tp <> nil do begin {count the parms} pCount := pCount-1; tp := tp^.right; end; {while} tp := parms; if pCount <> 0 then if ftype^.varargs and (pcount < 0) then hasVarargs := true else Error(85); end; {if} tp := parms; {generate the parameters} numParms := 0; lDoDispose := doDispose; doDispose := false; while tp <> nil do begin if tp^.middle <> nil then begin lnumErrors := numErrors; kind := ExpressionKind(tp^.middle); if numErrors = lnumErrors then if kind in [structType,unionType] then begin GenerateCode(tp^.middle); if expressionType^.size & $FFFF8000 <> 0 then Error(61); Gen1t(pc_ldc, long(expressionType^.size).lsw, cgWord); Gen0(pc_psh); end {else if} else GenerateCode(tp^.middle); if fmt <> fmt_none then begin new(tfp); tfp^.next := fp; tfp^.tk := tp^.middle; tfp^.ty := expressionType; fp := tfp; end; if prototype then begin if pCount = 0 then begin if parameters <> nil then begin AssignmentConversion(parameters^.parameterType, expressionType, lastWasConst, lastConst, true, false); end; {if} parameters := parameters^.next; end {if} else pCount := pCount+1; end; {if} Gen0t(pc_stk, UsualUnaryConversions); if numParms <> 0 then Gen0t(pc_bno, UsualUnaryConversions); numParms := numParms+1; end; {if} tp := tp^.right; end; {while} if fmt <> fmt_none then FormatCheck(fmt, fp); doDispose := lDoDispose; if numParms = 0 then Gen0(pc_nop); if ftype^.isPascal then {restore parm order} Reverse; if doDispose then begin {dispose of leaf nodes} DisposeTree(parms^.middle); DisposeTree(parms^.right); end; {if} end; {FunctionParms} begin {FunctionCall} {find the type of the function} indirect := true; {assume an indirect call} hasVarargs := false; {assume no variable arguments} ftree := tree^.left; {get the function tree} if ftree^.token.kind = ident then {check for direct calls} if ftree^.id^.itype^.kind = functionType then begin indirect := false; fType := ftree^.id^.itype; {get the function type} end; {if} if indirect then begin {get type for indirect call} ldoDispose := doDispose; doDispose := false; lcodeGeneration := codeGeneration; codeGeneration := false; GenerateCode(ftree); doDispose := ldoDispose; codeGeneration := lCodeGeneration and (numErrors = 0); ftype := expressionType; while ftype^.kind in [pointerType,arrayType] do ftype := ftype^.ptype; end; {if} {make sure the identifier is really a function} if ftype^.kind <> functionType then Error(114) else begin {generate function parameters} FunctionParms (tree, fType); {generate the function call} expressionType := ftype^.fType; if expressionType^.kind in [structType,unionType] then expressionType := uLongPtr; if (ftype^.toolNum = 0) and (ftype^.dispatcher = 0) then begin if indirect then begin fntype := expressionType; GenerateCode(ftree); expressionType := fntype; Gen1t(pc_cui, ord(hasVarargs and strictVararg), UsualUnaryConversions); end {if} else begin fname := ftree^.id^.name; if ftype^.isPascal then begin fname := pointer(Malloc(length(fname^)+1)); CopyString(pointer(fname), pointer(ftree^.id^.name)); for i := 1 to length(fname^) do if fName^[i] in ['a'..'z'] then fName^[i] := chr(ord(fName^[i]) & $5F); end; {if} Gen1tName(pc_cup, ord(hasVarargs and strictVararg), UsualUnaryConversions, fname); end; {else} end {if} else GenTool(pc_tl1, ftype^.toolNum, long(ftype^.ftype^.size).lsw, ftype^.dispatcher); expressionType := ftype^.fType; lastWasConst := false; end; {else} end; {FunctionCall} procedure CompareCompatible (var t1,t2: typePtr; equality: boolean); { Make sure that it is legal to compare t1 to t2 } { } { parameters: } { t1,t2 - the types to compare } { equality - is this for an (in)equality comparison? } begin {CompareCompatible} if (t1^.kind = functionType) or (t2^.kind = functionType) then begin if not CompTypes(t1, t2) then Error(47) else if not looseTypeChecks and not equality then Error(47); end {if} else if t1^.kind in [pointerType,arrayType] then begin if t2^.kind in [pointerType,arrayType] then begin if CompTypes(t1^.ptype, t2^.ptype) then begin if not looseTypeChecks and not equality then if t1^.ptype^.kind = functionType then Error(47); end {if} else if (t1^.ptype^.kind=scalarType) and (t1^.ptype^.basetype=cgVoid) then begin if not looseTypeChecks then begin if not equality then Error(47) else if (not tlastwasconst) or (tlastconst <> 0) then if t2^.ptype^.kind = functionType then Error(47); end {if} end {else if} else if (t2^.ptype^.kind=scalarType) and (t2^.ptype^.basetype=cgVoid) then begin if not looseTypeChecks then begin if not equality then Error(47) else if (not lastwasconst) or (lastconst <> 0) then if t1^.ptype^.kind = functionType then Error(47); end {if} end {else if} else Error(47); t2 := ulongPtr; end {if} else if (not lastwasconst) or (lastconst <> 0) or (not equality and not looseTypeChecks) then Error(47); t1 := ulongPtr; end {if} else if expressionType^.kind in [pointerType,arrayType] then begin if (not equality) or (not tlastwasconst) or (tlastconst <> 0) then Error(47); t2 := ulongPtr; end; {else if} end; {CompareCompatible} procedure CheckDivByZero (var divisor: tokenType; opType: typePtr); { Check for division by (constant) zero. } { } { parameters: } { divisor - token for divisor } { opType - type of the result of the operation } begin {CheckDivByZero} if opType^.kind = scalarType then if opType^.baseType in [cgByte,cgWord,cgUByte,cgUWord,cgLong,cgULong,cgQuad,cgUQuad] then if ((divisor.class = intConstant) and (divisor.ival = 0)) or ((divisor.class = longConstant) and (divisor.lval = 0)) or ((divisor.class = longlongConstant) and (divisor.qval.lo = 0) and (divisor.qval.hi = 0)) or ((divisor.class = realConstant) and (divisor.rval = 0.0)) then Error(129); end; {CheckDivByZero} procedure CheckShiftOverflow (var shiftCountTok: tokenType; opType: typePtr); { Check for invalid (too large or negative) shift count. } { } { parameters: } { shiftCountTok - token for shift count } { opType - type of the result of the operation } var shiftCount: longint; begin {CheckShiftOverflow} if shiftCountTok.class = intConstant then shiftCount := shiftCountTok.ival else if shiftCountTok.class = longConstant then shiftCount := shiftCountTok.lval else if shiftCountTok.class = longlongConstant then begin if shiftCountTok.qval.hi = 0 then shiftCount := shiftCountTok.qval.lo else shiftCount := -1; end {else if} else shiftCount := 0; if (shiftCount <> 0) and (opType^.kind = scalarType) then begin if opType^.baseType in [cgByte,cgWord,cgUByte,cgUWord] then if (shiftCount < 0) or (shiftCount > 15) then Error(130); if opType^.baseType in [cgLong,cgULong] then if (shiftCount < 0) or (shiftCount > 31) then Error(130); if opType^.baseType in [cgQuad,cgUQuad] then if (shiftCount < 0) or (shiftCount > 63) then Error(130); end; {if} end; {CheckShiftOverflow} begin {GenerateCode} lastwasconst := false; isNullPtrConst := false; case tree^.token.kind of parameterOper: FunctionCall(tree); ident: begin tType := tree^.id^.itype; while tType^.kind = definedType do tType := tType^.dType; case tType^.kind of scalarType: begin LoadScalar(tree^.id); expressionType := tree^.id^.itype; end; pointerType: begin LoadScalar(tree^.id); expressionType := tree^.id^.itype; end; arrayType: begin LoadAddress(tree); expressionType := expressionType^.ptype; end; functionType: LoadAddress(tree); structType, unionType: begin LoadAddress(tree); if expressionType^.kind = pointerType then expressionType := expressionType^.ptype; end; enumConst: begin Gen1t(pc_ldc, tree^.id^.itype^.eval, cgWord); expressionType := intPtr; end; end; {case} end; compoundLiteral: begin AutoInit(tree^.id, 0, true); tree^.token.kind := ident; ldoDispose := doDispose; doDispose := false; GenerateCode(tree); doDispose := ldoDispose; tree^.token.kind := compoundliteral; if expressionType^.kind = scalarType then Gen0t(pc_bno, expressionType^.baseType) else Gen0t(pc_bno, cgULong); end; intConst,uintConst,ushortConst,charConst,scharConst,ucharConst: begin Gen1t(pc_ldc, tree^.token.ival, cgWord); lastwasconst := true; lastconst := tree^.token.ival; isNullPtrConst := tree^.token.ival = 0; if tree^.token.kind = intConst then expressionType := intPtr else if tree^.token.kind = uintConst then expressionType := uIntPtr else if tree^.token.kind = ushortConst then expressionType := uShortPtr else if tree^.token.kind = charConst then expressionType := charPtr else if tree^.token.kind = scharConst then expressionType := scharPtr else {if tree^.token.kind = ucharConst then} expressionType := ucharPtr; end; {case intConst,uintConst,ushortConst,charConst,scharConst,ucharConst} longConst,ulongConst: begin GenLdcLong(tree^.token.lval); if tree^.token.kind = longConst then expressionType := longPtr else expressionType := ulongPtr; lastwasconst := true; lastconst := tree^.token.lval; isNullPtrConst := tree^.token.lval = 0; end; {case longConst} longlongConst,ulonglongConst: begin GenLdcQuad(tree^.token.qval); if tree^.token.kind = longlongConst then expressionType := longlongPtr else expressionType := ulonglongPtr; if (tree^.token.qval.hi = 0) and (tree^.token.qval.lo >= 0) then begin lastwasconst := true; lastconst := tree^.token.qval.lo; end; {if} isNullPtrConst := (tree^.token.qval.hi = 0) and (tree^.token.qval.lo = 0); end; {case longlongConst} floatConst: begin GenLdcReal(tree^.token.rval); expressionType := floatPtr; end; {case floatConst} doubleConst: begin GenLdcReal(tree^.token.rval); expressionType := doublePtr; end; {case doubleConst} extendedConst: begin GenLdcReal(tree^.token.rval); expressionType := extendedPtr; end; {case extendedConst} compConst: begin GenLdcReal(tree^.token.rval); expressionType := compPtr; end; {case compConst} stringConst: begin GenS(pc_lca, tree^.token.sval); expressionType := StringType(tree^.token.prefix); end; {case stringConst} eqch: begin {=} L_Value(tree^.left); with tree^.left^ do begin if token.kind = ident then kind := id^.itype^.kind else kind := definedType; if kind = arrayType then if id^.storage = parameter then kind := pointerType; if (token.kind = ident) and (kind in [scalarType,pointerType]) then begin GenerateCode(tree^.right); with tree^.left^.id^ do begin if itype^.kind in [pointerType,arrayType] then lType := uLongPtr else lType := itype; AssignmentConversion(itype, expressionType, lastWasConst, lastConst, true, true); case storage of stackFrame, parameter: Gen2t(pc_cop, lln, 0, lType^.baseType); external, global, private: Gen1tName(pc_cpo, 0, lType^.baseType, name); otherwise: ; end; {case} end; {with} end {if} else begin LoadAddress(tree^.left); lType := expressionType; lisBitField := isBitField; lbitDisp := bitDisp; lbitSize := bitSize; if lType^.kind = arrayType then lType := lType^.aType else if lType^.kind = pointerType then lType := lType^.pType; GenerateCode(tree^.right); AssignmentConversion(lType, expressionType, lastWasConst, lastConst, true, true); while lType^.kind = definedType do lType := lType^.dType; case lType^.kind of scalarType: if lisBitField then Gen2t(pc_cbf, lbitDisp, lbitSize, lType^.baseType) else Gen0t(pc_cpi, lType^.baseType); pointerType: Gen0t(pc_cpi, cgULong); structType,unionType: Gen2(pc_mov, long(lType^.size).msw, long(lType^.size).lsw); otherwise: Error(47); end; {case} end; {else} end; {with} end; {=} pluseqop, {+=} minuseqop, {-=} asteriskeqop, {*=} slasheqop, {/=} percenteqop, {%=} ltlteqop, {<<=} gtgteqop, {>>=} andeqop, {&=} caroteqop, {^=} bareqop: with tree^.left^ do {|=} begin L_Value(tree^.left); if (token.kind = ident) and ((id^.itype^.kind in [scalarType,pointerType]) or ((id^.itype^.kind = arrayType) and (id^.storage = parameter))) then begin doingScalar := true; LoadScalar(id); lType := id^.itype; t1 := 0; end {if} else begin doingScalar := false; LoadAddress(tree^.left); lisBitField := isBitField; lbitDisp := bitDisp; lbitSize := bitSize; t1 := GetTemp(cgLongSize); Gen2t(pc_str, t1, 0, cgULong); Gen2t(pc_lod, t1, 0, cgULong); Gen2t(pc_lod, t1, 0, cgULong); lType := expressionType^.pType; isVolatile := tqVolatile in lType^.qualifiers; if isBitField then begin if unsigned then Gen2t(pc_lbu, bitDisp, bitSize, lType^.baseType) else Gen2t(pc_lbf, bitDisp, bitSize, lType^.baseType); end {if} else if lType^.kind = pointerType then Gen2t(pc_ind, ord(isVolatile), 0, cgULong) else Gen2t(pc_ind, ord(isVolatile), 0, lType^.baseType); end; {else} if tqConst in lType^.qualifiers then Error(93); if doingScalar and (ltype^.kind = arrayType) and (id^.storage = parameter) then kind := pointerType else kind := lType^.kind; GenerateCode(tree^.right); if expressionType^.kind <> scalarType then Error(66); if tree^.token.kind in [gtgteqop,ltlteqop] then if kind = scalarType then if expressionType^.kind = scalarType then begin if expressionType^.baseType in [cgReal,cgDouble,cgComp,cgExtended,cgVoid] then Error(66); et := UsualUnaryConversions; if ltype^.baseType in [cgQuad,cgUQuad] then begin if not (et in [cgWord,cgUWord]) then begin Gen2(pc_cnv, et, ord(cgWord)); end; {if} expressionType := lType; end {if} else if et <> Unary(ltype^.baseType) then begin Gen2(pc_cnv, et, ord(Unary(ltype^.baseType))); expressionType := lType; end; {if} end; {if} if kind <> pointerType then et := UsualBinaryConversions(lType) else et := ccPointer; case tree^.token.kind of pluseqop: if kind = pointerType then begin ChangePointer(pc_adl, lType^.pType^.size, UsualUnaryConversions); expressionType := lType; end else if et in [cgWord,cgUWord] then Gen0(pc_adi) else if et in [cgLong,cgULong] then Gen0(pc_adl) else if et in [cgQuad,cgUQuad] then Gen0(pc_adq) else if et in [cgReal,cgDouble,cgComp,cgExtended] then Gen0(pc_adr) else Error(66); minuseqop: if kind = pointerType then begin ChangePointer(pc_sbl, lType^.pType^.size, UsualUnaryConversions); expressionType := lType; end else if et in [cgWord,cgUWord] then Gen0(pc_sbi) else if et in [cgLong,cgULong] then Gen0(pc_sbl) else if et in [cgQuad,cgUQuad] then Gen0(pc_sbq) else if et in [cgReal,cgDouble,cgComp,cgExtended] then Gen0(pc_sbr) else Error(66); asteriskeqop: if et = cgWord then Gen0(pc_mpi) else if et = cgUWord then Gen0(pc_umi) else if et = cgLong then Gen0(pc_mpl) else if et = cgULong then Gen0(pc_uml) else if et = cgQuad then Gen0(pc_mpq) else if et = cgUQuad then Gen0(pc_umq) else if et in [cgReal,cgDouble,cgComp,cgExtended] then Gen0(pc_mpr) else Error(66); slasheqop: if et = cgWord then Gen0(pc_dvi) else if et = cgUWord then Gen0(pc_udi) else if et = cgLong then Gen0(pc_dvl) else if et = cgULong then Gen0(pc_udl) else if et = cgQuad then Gen0(pc_dvq) else if et = cgUQuad then Gen0(pc_udq) else if et in [cgReal,cgDouble,cgComp,cgExtended] then Gen0(pc_dvr) else Error(66); percenteqop: if et = cgWord then Gen0(pc_mod) else if et = cgUWord then Gen0(pc_uim) else if et = cgLong then Gen0(pc_mdl) else if et = cgULong then Gen0(pc_ulm) else if et = cgQuad then Gen0(pc_mdq) else if et = cgUQuad then Gen0(pc_uqm) else Error(66); ltlteqop: if et in [cgWord,cgUWord] then Gen0(pc_shl) else if et in [cgLong,cgULong] then Gen0(pc_sll) else if et in [cgQuad,cgUQuad] then Gen0(pc_slq) else Error(66); gtgteqop: if et = cgWord then Gen0(pc_shr) else if et = cgUWord then Gen0(pc_usr) else if et = cgLong then Gen0(pc_slr) else if et = cgULong then Gen0(pc_vsr) else if et = cgQuad then Gen0(pc_sqr) else if et = cgUQuad then Gen0(pc_wsr) else Error(66); andeqop: if et in [cgWord,cgUWord] then Gen0(pc_bnd) else if et in [cgLong,cgULong] then Gen0(pc_bal) else if et in [cgQuad,cgUQuad] then Gen0(pc_baq) else Error(66); caroteqop: if et in [cgWord,cgUWord] then Gen0(pc_bxr) else if et in [cgLong,cgULong] then Gen0(pc_blx) else if et in [cgQuad,cgUQuad] then Gen0(pc_bqx) else Error(66); bareqop: if et in [cgWord,cgUWord] then Gen0(pc_bor) else if et in [cgLong,cgULong] then Gen0(pc_blr) else if et in [cgQuad,cgUQuad] then Gen0(pc_bqr) else Error(66); otherwise: Error(57); end; {case} if ((lint & lintOverflow) <> 0) then begin if tree^.token.kind in [slasheqop,percenteqop] then CheckDivByZero(tree^.right^.token, lType) else if tree^.token.kind in [ltlteqop,gtgteqop] then CheckShiftOverflow(tree^.right^.token, lType); end; {if} AssignmentConversion(lType,expressionType,false,0,true,true); if doingScalar then begin if kind = pointerType then lType := uLongPtr; case id^.storage of stackFrame, parameter: Gen2t(pc_cop, id^.lln, 0, lType^.baseType); external, global, private: Gen1tName(pc_cpo, 0, lType^.baseType, id^.name); otherwise: ; end; {case} end {if} else begin if lisBitField then Gen2t(pc_cbf, lbitDisp, lbitSize, lType^.baseType) else begin if ltype^.kind in [pointerType,arrayType] then lType := uLongPtr; Gen0t(pc_cpi, lType^.baseType); end; {else} Gen0t(pc_bno, lType^.baseType); end; {else} if t1 <> 0 then FreeTemp(t1, cgLongSize); end; {with} commach: begin {,} GenerateCode(tree^.left); if expressionType^.baseType <> cgVoid then Gen0t(pc_pop, UsualUnaryConversions); GenerateCode(tree^.right); Gen0t(pc_bno, UsualUnaryConversions); {result type is already in expressionType} end; {case commach} barbarop: begin {||} GenerateCode(tree^.left); if expressionType^.kind in [pointerType,arrayType] then expressionType := uLongPtr else begin et := UsualUnaryConversions; if et in [cgReal,cgDouble,cgComp,cgExtended] then begin GenLdcReal(0.0); Gen0t(pc_neq, cgExtended); expressionType := intPtr; end {if} else if et in [cgQuad,cgUQuad] then begin GenLdcQuad(longlong0); Gen0t(pc_neq, et); expressionType := intPtr; end; {else if} end; {else} lType := expressionType; GenerateCode(tree^.right); if expressionType^.kind in [pointerType,arrayType] then expressionType := uLongPtr else begin et := UsualUnaryConversions; if et in [cgReal,cgDouble,cgComp,cgExtended] then begin GenLdcReal(0.0); Gen0t(pc_neq, cgExtended); expressionType := intPtr; end {if} else if et in [cgQuad,cgUQuad] then begin GenLdcQuad(longlong0); Gen0t(pc_neq, et); expressionType := intPtr; end; {else if} end; {else} case UsualBinaryConversions(lType) of cgByte,cgUByte,cgWord,cgUWord: Gen0(pc_ior); cgLong,cgULong: Gen0(pc_lor); otherwise: error(66); end; {case} expressionType := intPtr; end; {case barbarop} andandop: begin {&&} GenerateCode(tree^.left); if expressionType^.kind in [pointerType,arrayType] then expressionType := uLongPtr else begin et := UsualUnaryConversions; if et in [cgReal,cgDouble,cgComp,cgExtended] then begin GenLdcReal(0.0); Gen0t(pc_neq, cgExtended); expressionType := intPtr; end {if} else if et in [cgQuad,cgUQuad] then begin GenLdcQuad(longlong0); Gen0t(pc_neq, et); expressionType := intPtr; end; {else if} end; {else} lType := expressionType; GenerateCode(tree^.right); if expressionType^.kind in [pointerType,arrayType] then expressionType := uLongPtr else begin et := UsualUnaryConversions; if et in [cgReal,cgDouble,cgComp,cgExtended] then begin GenLdcReal(0.0); Gen0t(pc_neq, cgExtended); expressionType := intPtr; end {if} else if et in [cgQuad,cgUQuad] then begin GenLdcQuad(longlong0); Gen0t(pc_neq, et); expressionType := intPtr; end; {else if} end; {else} case UsualBinaryConversions(lType) of cgByte,cgUByte,cgWord,cgUWord: Gen0(pc_and); cgLong,cgULong: Gen0(pc_lnd); otherwise: error(66); end; {case} expressionType := intPtr; end; {case andandop} carotch: begin {^} GenerateCode(tree^.left); lType := expressionType; GenerateCode(tree^.right); if (lType^.kind <> scalarType) or (expressionType^.kind <> scalarType) then Error(66) else case UsualBinaryConversions(lType) of cgByte,cgUByte,cgWord,cgUWord: Gen0(pc_bxr); cgLong,cgULong: Gen0(pc_blx); cgQuad,cgUQuad: Gen0(pc_bqx); otherwise: error(66); end; {case} end; {case carotch} barch: begin {|} GenerateCode(tree^.left); lType := expressionType; GenerateCode(tree^.right); if (lType^.kind <> scalarType) or (expressionType^.kind <> scalarType) then Error(66) else case UsualBinaryConversions(lType) of cgByte,cgUByte,cgWord,cgUWord: Gen0(pc_bor); cgLong,cgULong: Gen0(pc_blr); cgQuad,cgUQuad: Gen0(pc_bqr); otherwise: error(66); end; {case} end; {case barch} andch: begin {&} GenerateCode(tree^.left); lType := expressionType; GenerateCode(tree^.right); if (lType^.kind <> scalarType) or (expressionType^.kind <> scalarType) then Error(66) else case UsualBinaryConversions(lType) of cgByte,cgUByte,cgWord,cgUWord: Gen0(pc_bnd); cgLong,cgULong: Gen0(pc_bal); cgQuad,cgUQuad: Gen0(pc_baq); otherwise: error(66); end; {case} end; {case andch} ltltop: begin {<<} GenerateCode(tree^.left); if (expressionType^.kind <> scalarType) then error(66); et := UsualUnaryConversions; lType := expressionType; GenerateCode(tree^.right); if (expressionType^.kind <> scalarType) or not (expressionType^.baseType in [cgByte,cgUByte,cgWord,cgUWord,cgLong,cgULong,cgQuad,cgUQuad]) then error(66); if et in [cgQuad,cgUQuad] then begin if not (expressionType^.baseType in [cgWord,cgUWord]) then Gen2(pc_cnv, ord(expressionType^.baseType), ord(cgWord)); end {if} else if expressionType^.baseType <> et then Gen2(pc_cnv, ord(expressionType^.baseType), ord(et)); case et of cgByte,cgUByte,cgWord,cgUWord: Gen0(pc_shl); cgLong,cgULong: Gen0(pc_sll); cgQuad,cgUQuad: Gen0(pc_slq); otherwise: error(66); end; {case} expressionType := lType; if ((lint & lintOverflow) <> 0) then CheckShiftOverflow(tree^.right^.token, expressionType); end; {case ltltop} gtgtop: begin {>>} GenerateCode(tree^.left); if (expressionType^.kind <> scalarType) then error(66); et := UsualUnaryConversions; lType := expressionType; GenerateCode(tree^.right); if (expressionType^.kind <> scalarType) or not (expressionType^.baseType in [cgByte,cgUByte,cgWord,cgUWord,cgLong,cgULong,cgQuad,cgUQuad]) then error(66); if et in [cgQuad,cgUQuad] then begin if not (expressionType^.baseType in [cgWord,cgUWord]) then Gen2(pc_cnv, ord(expressionType^.baseType), ord(cgWord)); end {if} else if expressionType^.baseType <> et then Gen2(pc_cnv, ord(expressionType^.baseType), ord(et)); case et of cgByte,cgWord: Gen0(pc_shr); cgUByte,cgUWord: Gen0(pc_usr); cgLong: Gen0(pc_slr); cgULong: Gen0(pc_vsr); cgQuad: Gen0(pc_sqr); cgUQuad: Gen0(pc_wsr); otherwise: error(66); end; {case} expressionType := lType; if ((lint & lintOverflow) <> 0) then CheckShiftOverflow(tree^.right^.token, expressionType); end; {case gtgtop} plusch: begin {+} if ExpressionKind(tree^.right) in [arrayType,pointerType] then begin tree^.middle := tree^.right; tree^.right := tree^.left; tree^.left := tree^.middle; end; {if} GenerateCode(tree^.left); lType := expressionType; GenerateCode(tree^.right); if lType^.kind in [arrayType,pointerType] then begin if expressionType^.kind <> scalarType then error(66); {pointer addition} et := UsualUnaryConversions; expressionType := lType; if lType^.kind = arrayType then lType := lType^.aType else lType := lType^.pType; ChangePointer(pc_adl, lType^.size, et); if expressionType^.kind = arrayType then expressionType := MakePointerTo(expressionType^.aType); end {if} else begin {scalar addition} case UsualBinaryConversions(lType) of cgByte,cgUByte,cgWord,cgUWord: Gen0(pc_adi); cgLong,cgULong: Gen0(pc_adl); cgQuad,cgUQuad: Gen0(pc_adq); cgReal,cgDouble,cgComp,cgExtended: Gen0(pc_adr); otherwise: error(66); end; {case} end; {else} end; {case plusch} minusch: begin {-} GenerateCode(tree^.left); lType := expressionType; GenerateCode(tree^.right); if lType^.kind in [pointerType,arrayType] then begin if lType^.kind = arrayType then size := lType^.aType^.size else size := lType^.pType^.size; if expressionType^.kind in [arrayType,pointerType] then begin {subtraction of two pointers} if size = 0 then Error(122) {NOTE: assumes aType & pType overlap in typeRecord} else if not CompTypes(lType^.aType, expressionType^.aType) then Error(47); Gen0(pc_sbl); if size <> 1 then begin GenLdcLong(size); Gen0(pc_dvl); end; {if} lType := longPtr; end {if} else {subtract a scalar from a pointer} ChangePointer(pc_sbl, size, UsualUnaryConversions); expressionType := lType; if expressionType^.kind = arrayType then expressionType := MakePointerTo(expressionType^.aType); end {if} else begin {scalar subtraction} if expressionType^.kind <> scalarType then error(66) else case UsualBinaryConversions(lType) of cgByte,cgUByte,cgWord,cgUWord: Gen0(pc_sbi); cgLong,cgULong: Gen0(pc_sbl); cgQuad,cgUQuad: Gen0(pc_sbq); cgReal,cgDouble,cgComp,cgExtended: Gen0(pc_sbr); otherwise: error(66); end; {case} end; {else} end; {case minusch} asteriskch: begin {*} GenerateCode(tree^.left); lType := expressionType; GenerateCode(tree^.right); if (lType^.kind <> scalarType) or (expressionType^.kind <> scalarType) then Error(66) else case UsualBinaryConversions(lType) of cgByte,cgWord: Gen0(pc_mpi); cgUByte,cgUWord: Gen0(pc_umi); cgLong: Gen0(pc_mpl); cgULong: Gen0(pc_uml); cgQuad: Gen0(pc_mpq); cgUQuad: Gen0(pc_umq); cgReal,cgDouble,cgComp,cgExtended: Gen0(pc_mpr); otherwise: error(66); end; {case} end; {case asteriskch} slashch: begin {/} GenerateCode(tree^.left); lType := expressionType; GenerateCode(tree^.right); if (lType^.kind <> scalarType) or (expressionType^.kind <> scalarType) then Error(66) else case UsualBinaryConversions(lType) of cgByte,cgWord: Gen0(pc_dvi); cgUByte,cgUWord: Gen0(pc_udi); cgLong: Gen0(pc_dvl); cgULong: Gen0(pc_udl); cgQuad: Gen0(pc_dvq); cgUQuad: Gen0(pc_udq); cgReal,cgDouble,cgComp,cgExtended: Gen0(pc_dvr); otherwise: error(66); end; {case} if ((lint & lintOverflow) <> 0) then CheckDivByZero(tree^.right^.token, expressionType); end; {case slashch} percentch: begin {%} GenerateCode(tree^.left); lType := expressionType; GenerateCode(tree^.right); if (lType^.kind <> scalarType) or (expressionType^.kind <> scalarType) then Error(66) else case UsualBinaryConversions(lType) of cgByte,cgWord: Gen0(pc_mod); cgUByte,cgUWord: Gen0(pc_uim); cgLong: Gen0(pc_mdl); cgULong: Gen0(pc_ulm); cgQuad: Gen0(pc_mdq); cgUQuad: Gen0(pc_uqm); otherwise: error(66); end; {case} if ((lint & lintOverflow) <> 0) then CheckDivByZero(tree^.right^.token, expressionType); end; {case percentch} eqeqop, {==} exceqop: begin {!=} GenerateCode(tree^.left); lType := expressionType; tlastwasconst := lastwasconst; tlastconst := lastconst; GenerateCode(tree^.right); CompareCompatible(ltype, expressionType, true); if tree^.token.kind = eqeqop then Gen0t(pc_equ, UsualBinaryConversions(lType)) else Gen0t(pc_neq, UsualBinaryConversions(lType)); expressionType := intPtr; end; {case exceqop,eqeqop} lteqop, {<=} gteqop, {>=} ltch, {<} gtch: begin {>} GenerateCode(tree^.left); lType := expressionType; GenerateCode(tree^.right); CompareCompatible(ltype, expressionType, false); if tree^.token.kind = lteqop then Gen0t(pc_leq, UsualBinaryConversions(lType)) else if tree^.token.kind = gteqop then Gen0t(pc_geq, UsualBinaryConversions(lType)) else if tree^.token.kind = ltch then Gen0t(pc_les, UsualBinaryConversions(lType)) else {if tree^.token.kind = gtch then} Gen0t(pc_grt, UsualBinaryConversions(lType)); expressionType := intPtr; end; {case lteqop,gteqop,ltch,gtch} uminus: begin {unary -} GenerateCode(tree^.left); if expressionType^.kind <> scalarType then error(66) else case UsualUnaryConversions of cgByte,cgUByte,cgWord,cgUWord: Gen0(pc_ngi); cgLong,cgULong: Gen0(pc_ngl); cgQuad,cgUQuad: Gen0(pc_ngq); cgReal,cgDouble,cgComp,cgExtended: Gen0(pc_ngr); otherwise: error(66); end; {case} end; {case uminus} uplus: begin {unary +} GenerateCode(tree^.left); if expressionType^.kind <> scalarType then error(66) else case UsualUnaryConversions of cgByte,cgUByte,cgWord,cgUWord,cgLong,cgULong,cgQuad,cgUQuad, cgReal,cgDouble,cgComp,cgExtended: ; otherwise: error(66); end; {case} end; {case uplus} tildech: begin {~} GenerateCode(tree^.left); if expressionType^.kind <> scalarType then error(66) else case UsualUnaryConversions of cgByte,cgUByte,cgWord,cgUWord: Gen0(pc_bnt); cgLong,cgULong: Gen0(pc_bnl); cgQuad,cgUQuad: Gen0(pc_bnq); otherwise: error(66); end; {case} end; {case tildech} excch: begin {!} GenerateCode(tree^.left); if expressionType^.kind = pointerType then expressionType := uLongPtr; case UsualUnaryConversions of cgByte,cgUByte,cgWord,cgUWord: Gen0(pc_not); cgLong,cgULong: begin GenLdcLong(0); Gen0t(pc_equ, cgLong); end; cgQuad,cgUQuad: begin GenLdcQuad(longlong0); Gen0t(pc_equ, cgQuad); end; cgReal,cgDouble,cgComp,cgExtended: begin GenLdcReal(0.0); Gen0t(pc_equ, cgExtended); end; otherwise: error(66); end; {case} expressionType := intPtr; end; {case excch} plusplusop: {prefix ++} DoIncDec(tree^.left, pc_lil, pc_gil, pc_iil); opplusplus: {postfix ++} DoIncDec(tree^.left, pc_lli, pc_gli, pc_ili); minusminusop: {prefix --} DoIncDec(tree^.left, pc_ldl, pc_gdl, pc_idl); opminusminus: {postfix --} DoIncDec(tree^.left, pc_lld, pc_gld, pc_ild); uand: begin {unary & (address operator)} if not (tree^.left^.token.kind in [ident,compoundliteral,stringconst,uasterisk]) then L_Value(tree^.left); LoadAddress(tree^.left); if tree^.left^.token.kind = stringconst then begin {build pointer-to-array type for address of string constant} tType := pointer(Malloc(sizeof(typeRecord))); tType^ := StringType(tree^.left^.token.prefix)^; tType^.size := tree^.left^.token.sval^.length; tType^.saveDisp := 0; tType^.elements := tType^.size div tType^.aType^.size; expressionType := MakePointerTo(tType); end {if} else if expressionType^.kind = arrayType then expressionType := MakePointerTo(expressionType^.aType); end; {case uand} uasterisk: begin {unary * (indirection)} GenerateCode(tree^.left); lType := expressionType; if lType^.kind in [functiontype,arrayType,pointerType] then begin if lType^.kind = arrayType then lType := lType^.aType else if lType^.kind = pointerType then lType := lType^.pType; expressionType := lType; isVolatile := tqVolatile in lType^.qualifiers; if lType^.kind = scalarType then if lType^.baseType = cgVoid then Gen2(pc_cnv, cgULong, cgVoid) else Gen2t(pc_ind, ord(isVolatile), 0, lType^.baseType) else if lType^.kind = pointerType then Gen2t(pc_ind, ord(isVolatile), 0, cgULong) else if not ((lType^.kind in [functionType,arrayType,structType,unionType]) or ((lType^.kind = definedType) and {handle const struct/union} (lType^.dType^.kind in [structType,unionType]))) then Error(79); end {if} else Error(79); end; {case uasterisk} dotch: begin {.} LoadAddress(tree^.left); lType := expressionType; if lType^.kind in [arrayType,pointerType,structType,unionType] then begin if lType^.kind = arrayType then lType := lType^.aType else if lType^.kind = pointerType then lType := lType^.pType; DoSelection(lType, tree^.right, size); if (size & $00007FFF) <> size then begin GenLdcLong(size); Gen0(pc_adl); size := 0; end; {else} kind := expressionType^.kind; isVolatile := tqVolatile in expressionType^.qualifiers; if kind = scalarType then begin et := expressionType^.baseType; if isBitField then begin GenLdcLong(size); Gen0(pc_adl); if unsigned then Gen2t(pc_lbu, bitDisp, bitSize, et) else Gen2t(pc_lbf, bitDisp, bitSize, et); end {if} else Gen2t(pc_ind, ord(isVolatile), long(size).lsw, et); end {if} else if kind = pointerType then Gen2t(pc_ind, ord(isVolatile), long(size).lsw, cgULong) else if kind = enumType then Gen2t(pc_ind, ord(isVolatile), long(size).lsw, cgWord) else if size <> 0 then Gen1t(pc_inc, long(size).lsw, cgULong); end {if} else Error(79); end; {case dotch} colonch: begin {? :} GenerateCode(tree^.left); {evaluate the condition} CompareToZero(pc_neq); GenerateCode(tree^.middle); {evaluate true expression} ValueExpressionConversions; lType := expressionType; tlastWasNullPtrConst := lastWasNullPtrConst; GenerateCode(tree^.right); {evaluate false expression} ValueExpressionConversions; {check, compute, and convert types} if (lType^.kind = pointerType) or (expressionType^.kind = pointerType) then begin if tlastWasNullPtrConst then begin if lType^.kind = scalarType then Gen2(pc_cnn, ord(lType^.baseType), ord(cgULong)); end {if} else if lastWasNullPtrConst then begin if expressionType^.kind = scalarType then Gen2(pc_cnv, ord(expressionType^.baseType), ord(cgULong)); expressionType := lType; end {if} else if lType^.kind <> expressionType^.kind then {not both pointers} Error(47) else if IsVoid(lType^.pType) or IsVoid(expressionType^.pType) then begin if not looseTypeChecks then if (lType^.pType^.kind = functionType) or (expressionType^.pType^.kind = functionType) then Error(47); expressionType := MakePointerTo(MakeQualifiedType(voidPtr, lType^.pType^.qualifiers+expressionType^.pType^.qualifiers)); end {else if} else if CompTypes(Unqualify(lType^.pType), Unqualify(expressionType^.pType)) then begin if not looseTypeChecks then if not StrictCompTypes(Unqualify(lType^.pType), Unqualify(expressionType^.pType)) then Error(47); expressionType := MakePointerTo(MakeQualifiedType(MakeCompositeType( Unqualify(lType^.pType),Unqualify(expressionType^.pType)), lType^.pType^.qualifiers+expressionType^.pType^.qualifiers)); end {else if} else Error(47); et := cgULong; end {if} else if lType^.kind in [structType, unionType] then begin if not CompTypes(lType, expressionType) then Error(47); et := cgULong; end {if} else begin if IsVoid(lType) and IsVoid(expressionType) then et := cgVoid else et := UsualBinaryConversions(lType); end; {else} {generate the operation} Gen0(pc_bno); Gen0t(pc_tri, et); end; {case colonch} castoper: begin {(cast)} GenerateCode(tree^.left); if lastWasNullPtrConst then if expressionType^.kind = scalarType then if tree^.castType^.kind = pointerType then if IsVoid(tree^.castType^.pType) then if tree^.castType^.pType^.qualifiers = [] then isNullPtrConst := true; Cast(tree^.castType); end; {case castoper} otherwise: Error(57); end; {case} if doDispose then dispose(tree); lastWasNullPtrConst := isNullPtrConst; end; {GenerateCode} procedure Expression {kind: expressionKind; stopSym: tokenSet}; { handle an expression } { } { parameters: } { kind - Kind of expression; determines what operations } { and what kind of operands are allowed. } { stopSym - Set of symbols that can mark the end of an } { expression; used to skip tokens after syntax } { errors and to block certain operations. For } { example, the comma operator is not allowed in } { an expression when evaluating a function } { parameter list. } { } { variables: } { realExpressionValue - value of a real constant } { expression } { expressionValue - value of a constant expression } { expressionType - type of the expression } label 1; var lcodeGeneration: boolean; {local copy of codeGeneration} ldoDispose: boolean; {local copy of doDispose} tree: tokenPtr; {expression tree} castValue: tokenPtr; {element being type cast} begin {Expression} errorFound := false; {no error so far} tree := ExpressionTree(kind, stopSym); {create the expression tree} if kind = normalExpression then begin {generate code from the expression tree} if not errorFound then begin doDispose := true; GenerateCode(tree); end {if} else expressionType := intPtr; {set default type in case of error} end {if} else begin {record the expression for an initializer} initializerTree := tree; isConstant := false; llExpressionValue.lo := 0; llExpressionValue.hi := 0; expressionIsLongLong := false; if errorFound then begin DisposeTree(initializerTree); initializerTree := nil; expressionType := intPtr; {set default type in case of error} end {if} else begin ldoDispose := doDispose; {find the expression type} doDispose := false; lcodeGeneration := codeGeneration; codeGeneration := false; GenerateCode(tree); doDispose := ldoDispose; codeGeneration := lCodeGeneration and (numErrors = 0); {record the expression} if tree^.token.kind = castoper then begin castValue := tree^.left; while castValue^.token.kind = castoper do castValue := castValue^.left; if castValue^.token.kind in [intconst,uintconst,ushortconst,charconst,scharconst,ucharconst] then begin expressionValue := castValue^.token.ival; isConstant := true; expressionType := tree^.castType; if (castValue^.token.kind in [uintconst,ushortconst]) or (expressionType^.kind = pointerType) then expressionValue := expressionValue & $0000FFFF; goto 1; end; {if} if castValue^.token.kind in [longconst,ulongconst] then begin expressionValue := castValue^.token.lval; isConstant := true; expressionType := tree^.castType; goto 1; end; {if} end; {if} if tree^.token.kind in [intconst,charconst,scharconst,ucharconst] then begin expressionValue := tree^.token.ival; if tree^.token.kind = intconst then expressionType := intPtr else if tree^.token.kind = charconst then expressionType := charPtr else if tree^.token.kind = scharconst then expressionType := scharPtr else {if tree^.token.kind = ucharconst then} expressionType := ucharPtr; isConstant := true; end {else if} else if tree^.token.kind in [uintconst,ushortconst] then begin expressionValue := tree^.token.ival; expressionValue := expressionValue & $0000FFFF; if tree^.token.kind = uintconst then expressionType := uIntPtr else {if tree^.token.kind = ushortconst then} expressionType := uShortPtr; isConstant := true; end {else if} else if tree^.token.kind = longconst then begin expressionValue := tree^.token.lval; expressionType := longPtr; isConstant := true; end {else if} else if tree^.token.kind = ulongconst then begin expressionValue := tree^.token.lval; expressionType := ulongPtr; isConstant := true; end {else if} else if tree^.token.kind = longlongconst then begin llExpressionValue := tree^.token.qval; expressionIsLongLong := true; if ((llExpressionValue.hi = 0) and (llExpressionValue.lo >= 0)) or ((llExpressionValue.hi = -1) and (llExpressionValue.lo < 0)) then expressionValue := llExpressionValue.lo else if llExpressionValue.hi < 0 then expressionValue := $80000000 else expressionValue := $7fffffff; expressionType := longLongPtr; isConstant := true; end {else if} else if tree^.token.kind = ulonglongconst then begin llExpressionValue := tree^.token.qval; expressionIsLongLong := true; if llExpressionValue.hi = 0 then expressionValue := llExpressionValue.lo else expressionValue := $FFFFFFFF; expressionType := ulongLongPtr; isConstant := true; end {else if} else if tree^.token.kind in [floatconst,doubleconst,extendedconst,compconst] then begin realExpressionValue := tree^.token.rval; if tree^.token.kind = extendedconst then expressionType := extendedPtr else if tree^.token.kind = doubleconst then expressionType := doublePtr else if tree^.token.kind = floatconst then expressionType := floatPtr else {if tree^.token.kind = compconst then} expressionType := compPtr; isConstant := true; if kind in [arrayExpression,preprocessorExpression] then begin expressionType := intPtr; expressionValue := 1; Error(47); end; {if} end {else if} else if tree^.token.kind = stringconst then begin expressionValue := ord4(tree^.token.sval); expressionType := StringType(tree^.token.prefix); isConstant := true; if kind in [arrayExpression,preprocessorExpression] then begin expressionType := intPtr; expressionValue := 1; Error(47); end; {if} end {else if} else if kind in [arrayExpression,preprocessorExpression] then begin DisposeTree(initializerTree); expressionValue := 1; end; {else if} end; {else} end; {else} 1: end; {Expression} procedure GetLLExpressionValue {var val: longlong}; { get the value of the last integer constant expression as a } { long long (whether it had long long type or not). } begin {GetLLExpressionValue} if expressionIsLongLong then val := llExpressionValue else begin val.lo := expressionValue; val.hi := 0; if expressionValue < 0 then if expressionType^.kind = scalarType then if expressionType^.baseType in [cgByte,cgWord,cgLong] then val.hi := -1; end; end; {GetLLExpressionValue} procedure InitExpression; { initialize the expression handler } begin {InitExpression} startTerm := [ident,intconst,uintconst,longconst,ulongconst,longlongconst, ulonglongconst,floatconst,doubleconst,extendedconst,compconst, charconst,scharconst,ucharconst,ushortconst,stringconst]; startExpression:= startTerm + [lparench,asteriskch,andch,plusch,minusch,excch,tildech,sizeofsy, plusplusop,minusminusop,typedef,_Alignofsy,_Genericsy]; end; {InitExpression} end. {$append 'expression.asm'}