mirror of
https://github.com/byteworksinc/ORCA-C.git
synced 2024-06-12 05:29:29 +00:00
Compare commits
No commits in common. "69320cd4d81a16f58aacc5908f786845d0cffd88" and "6b7414384f6bd8963c292056111232cce81dfaa1" have entirely different histories.
69320cd4d8
...
6b7414384f
|
|
@ -202,7 +202,6 @@ type
|
|||
barbarop,pluseqop,minuseqop,asteriskeqop,slasheqop,
|
||||
percenteqop,ltlteqop,gtgteqop,andeqop,caroteqop,
|
||||
bareqop,poundpoundop,dotdotdotsy,
|
||||
ppnumber, {preprocessing number (pp-token)}
|
||||
otherch, {other non-whitespace char (pp-token)}
|
||||
eolsy,eofsy, {control characters}
|
||||
typedef, {user types}
|
||||
|
|
@ -226,7 +225,7 @@ type
|
|||
tokenSet = set of tokenEnum;
|
||||
tokenClass = (reservedWord,reservedSymbol,identifier,intConstant,longConstant,
|
||||
longlongConstant,realConstant,stringConstant,otherCharacter,
|
||||
preprocessingNumber,macroParameter);
|
||||
macroParameter);
|
||||
identPtr = ^identRecord; {^ to a symbol table entry}
|
||||
tokenType = record {a token}
|
||||
kind: tokenEnum; {kind of token}
|
||||
|
|
@ -244,7 +243,6 @@ type
|
|||
ispstring: boolean;
|
||||
prefix: charStrPrefixEnum);
|
||||
otherCharacter: (ch: char); {used for preprocessing tokens only}
|
||||
preprocessingNumber: (errCode: integer); {used for pp tokens only}
|
||||
macroParameter: (pnum: integer);
|
||||
end;
|
||||
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@ uses CCommon, MM, Scanner, Symbol, CGI;
|
|||
{$segment 'HEADER'}
|
||||
|
||||
const
|
||||
symFileVersion = 44; {version number of .sym file format}
|
||||
symFileVersion = 42; {version number of .sym file format}
|
||||
|
||||
var
|
||||
inhibitHeader: boolean; {should .sym includes be blocked?}
|
||||
|
|
@ -722,7 +722,6 @@ procedure EndInclude {chPtr: ptr};
|
|||
WriteByte(ord(token.prefix));
|
||||
end;
|
||||
otherCharacter: WriteByte(ord(token.ch));
|
||||
preprocessingNumber:WriteWord(token.errCode);
|
||||
macroParameter: WriteWord(token.pnum);
|
||||
reservedSymbol: if token.kind in [lbracech,rbracech,lbrackch,
|
||||
rbrackch,poundch,poundpoundop] then
|
||||
|
|
@ -1393,7 +1392,6 @@ var
|
|||
token.prefix := charStrPrefixEnum(ReadByte);
|
||||
end;
|
||||
otherCharacter: token.ch := chr(ReadByte);
|
||||
preprocessingNumber: token.errCode := ReadWord;
|
||||
macroParameter: token.pnum := ReadWord;
|
||||
reservedSymbol: if token.kind in [lbracech,rbracech,lbrackch,
|
||||
rbrackch,poundch,poundpoundop] then
|
||||
|
|
|
|||
168
Scanner.pas
168
Scanner.pas
|
|
@ -805,7 +805,6 @@ if list or (numErr <> 0) then begin
|
|||
186: msg := @'lint: implicit conversion changes value of constant';
|
||||
187: msg := @'expression has incomplete struct or union type';
|
||||
188: msg := @'local variable used in asm statement is out of range for addressing mode';
|
||||
189: msg := @'malformed numeric constant';
|
||||
end; {case}
|
||||
if extraStr <> nil then begin
|
||||
extraStr^ := concat(msg^,extraStr^);
|
||||
|
|
@ -1098,8 +1097,6 @@ case token.kind of
|
|||
dotdotdotsy: write('...');
|
||||
|
||||
otherch: write(token.ch);
|
||||
|
||||
ppNumber: write(token.numString^);
|
||||
|
||||
macroParm: write('$', token.pnum:1);
|
||||
|
||||
|
|
@ -1121,11 +1118,16 @@ procedure CheckIdentifier; forward;
|
|||
{ See if an identifier is a reserved word, macro or typedef }
|
||||
|
||||
|
||||
procedure DoNumber; forward;
|
||||
procedure DoNumber (scanWork: boolean); forward;
|
||||
|
||||
{ Scan a number from workString }
|
||||
{ The current character starts a number - scan it }
|
||||
{ }
|
||||
{ Parameters: }
|
||||
{ scanWork - get characters from workString? }
|
||||
{ }
|
||||
{ Globals: }
|
||||
{ ch - first character in sequence; set to first char }
|
||||
{ after sequence }
|
||||
{ workString - string to take numbers from }
|
||||
|
||||
|
||||
|
|
@ -1372,12 +1374,6 @@ else if class1 in numericConstants then begin
|
|||
str2 := @reservedWords[kind2]
|
||||
else if kind2 = dotch then
|
||||
str2 := @'.'
|
||||
else if (kind2 = plusch)
|
||||
and (tk1.numString^[length(tk1.numString^)] in ['e','E','p','P']) then
|
||||
str2 := @'+'
|
||||
else if (kind2 = minusch)
|
||||
and (tk1.numString^[length(tk1.numString^)] in ['e','E','p','P']) then
|
||||
str2 := @'-'
|
||||
else begin
|
||||
Error(63);
|
||||
goto 1;
|
||||
|
|
@ -1386,7 +1382,7 @@ else if class1 in numericConstants then begin
|
|||
lt := token;
|
||||
lsaveNumber := saveNumber;
|
||||
saveNumber := true;
|
||||
DoNumber;
|
||||
DoNumber(true);
|
||||
saveNumber := lsaveNumber;
|
||||
tk1 := token;
|
||||
token := lt;
|
||||
|
|
@ -1394,15 +1390,14 @@ else if class1 in numericConstants then begin
|
|||
end {else if class1 in numericConstants}
|
||||
|
||||
else if kind1 = dotch then begin
|
||||
if class2 in numericConstants then
|
||||
if charKinds[ord(tk2.numString^[1])] = digit then begin
|
||||
workString := concat('.', tk2.numString^);
|
||||
lt := token;
|
||||
DoNumber;
|
||||
tk1 := token;
|
||||
token := lt;
|
||||
goto 1;
|
||||
end; {if}
|
||||
if class2 in numericConstants then begin
|
||||
workString := concat(tk1.numString^, tk2.numString^);
|
||||
lt := token;
|
||||
DoNumber(true);
|
||||
tk1 := token;
|
||||
token := lt;
|
||||
goto 1;
|
||||
end; {if}
|
||||
end {else if class1 in numericConstants}
|
||||
|
||||
else if kind1 = poundch then begin
|
||||
|
|
@ -2986,9 +2981,6 @@ var
|
|||
tk2^.token.sval^.str[i] then
|
||||
goto 3;
|
||||
end;
|
||||
preprocessingNumber:
|
||||
if tk1^.token.numString^ <> tk2^.token.numString^ then
|
||||
goto 3;
|
||||
macroParameter:
|
||||
if tk1^.token.pnum <> tk2^.token.pnum then
|
||||
goto 3;
|
||||
|
|
@ -3874,19 +3866,22 @@ Error(err);
|
|||
end; {Error2}
|
||||
|
||||
|
||||
procedure DoNumber;
|
||||
procedure DoNumber {scanWork: boolean};
|
||||
|
||||
{ Scan a number from workString }
|
||||
{ The current character starts a number - scan it }
|
||||
{ }
|
||||
{ Parameters: }
|
||||
{ scanWork - get characters from workString? }
|
||||
{ }
|
||||
{ Globals: }
|
||||
{ ch - first character in sequence; set to first char }
|
||||
{ after sequence }
|
||||
{ workString - string to take numbers from }
|
||||
|
||||
label 1,2;
|
||||
|
||||
var
|
||||
atEnd: boolean; {at end of workString?}
|
||||
c2: char; {next character to process}
|
||||
err: integer; {error code}
|
||||
i: integer; {loop index}
|
||||
isBin: boolean; {is the value a binary number?}
|
||||
isHex: boolean; {is the value a hex number?}
|
||||
|
|
@ -3909,13 +3904,17 @@ var
|
|||
{ Return the next character that is a part of the number }
|
||||
|
||||
begin {NextChar}
|
||||
if ord(workString[0]) <> numIndex then begin
|
||||
numIndex := numIndex+1;
|
||||
c2 := workString[numIndex];
|
||||
if scanWork then begin
|
||||
if ord(workString[0]) <> numIndex then begin
|
||||
numIndex := numIndex+1;
|
||||
c2 := workString[numIndex];
|
||||
end {if}
|
||||
else
|
||||
c2 := ' ';
|
||||
end {if}
|
||||
else begin
|
||||
atEnd := true;
|
||||
c2 := ' ';
|
||||
NextCh;
|
||||
c2 := ch;
|
||||
end; {else}
|
||||
end; {NextChar}
|
||||
|
||||
|
|
@ -3927,10 +3926,8 @@ var
|
|||
{ code never actually get converted to numeric constants. }
|
||||
|
||||
begin {FlagError}
|
||||
if err = 0 then
|
||||
err := errCode
|
||||
else if err <> errCode then
|
||||
err := 189;
|
||||
if not skipping then
|
||||
Error(errCode);
|
||||
end; {FlagError}
|
||||
|
||||
|
||||
|
|
@ -3977,7 +3974,6 @@ var
|
|||
|
||||
|
||||
begin {DoNumber}
|
||||
atEnd := false; {not at end}
|
||||
isBin := false; {assume it's not binary}
|
||||
isHex := false; {assume it's not hex}
|
||||
isReal := false; {assume it's an integer}
|
||||
|
|
@ -3985,10 +3981,13 @@ isLong := false; {assume a short integer}
|
|||
isLongLong := false;
|
||||
isFloat := false;
|
||||
unsigned := false; {assume signed numbers}
|
||||
err := 0; {no error so far}
|
||||
stringIndex := 0; {no digits so far...}
|
||||
numIndex := 0; {set up the scanner}
|
||||
NextChar;
|
||||
if scanWork then begin {set up the scanner}
|
||||
numIndex := 0;
|
||||
NextChar;
|
||||
end {if}
|
||||
else
|
||||
c2 := ch;
|
||||
if c2 = '.' then begin {handle the case of no leading digits}
|
||||
stringIndex := 1;
|
||||
numString[1] := '0';
|
||||
|
|
@ -4057,8 +4056,6 @@ while c2 in ['l','u','L','U'] do {check for long or unsigned}
|
|||
if c2 = c1 then begin
|
||||
NextChar;
|
||||
isLongLong := true;
|
||||
if isReal then
|
||||
FlagError(156);
|
||||
end {if}
|
||||
else
|
||||
isLong := true;
|
||||
|
|
@ -4072,6 +4069,10 @@ while c2 in ['l','u','L','U'] do {check for long or unsigned}
|
|||
unsigned := true;
|
||||
end; {else}
|
||||
if c2 in ['f','F'] then begin {allow F designator on reals}
|
||||
if unsigned then
|
||||
FlagError(91);
|
||||
if isLongLong then
|
||||
FlagError(156);
|
||||
if not isReal then begin
|
||||
FlagError(100);
|
||||
isReal := true;
|
||||
|
|
@ -4150,8 +4151,6 @@ else begin {hex, octal, & binary}
|
|||
token.qval.hi := 0;
|
||||
if isHex then begin
|
||||
i := 3;
|
||||
if length(numString) < 3 then
|
||||
FlagError(189);
|
||||
while i <= length(numString) do begin
|
||||
if token.qval.hi & $F0000000 <> 0 then begin
|
||||
i := maxint;
|
||||
|
|
@ -4170,8 +4169,6 @@ else begin {hex, octal, & binary}
|
|||
end {if}
|
||||
else if isBin then begin
|
||||
i := 3;
|
||||
if length(numString) < 3 then
|
||||
FlagError(189);
|
||||
while i <= length(numString) do begin
|
||||
if token.qval.hi & $80000000 <> 0 then begin
|
||||
i := maxint;
|
||||
|
|
@ -4187,7 +4184,7 @@ else begin {hex, octal, & binary}
|
|||
end; {while}
|
||||
end {if}
|
||||
else begin
|
||||
i := 2;
|
||||
i := 1;
|
||||
while i <= length(numString) do begin
|
||||
if token.qval.hi & $E0000000 <> 0 then begin
|
||||
i := maxint;
|
||||
|
|
@ -4232,18 +4229,14 @@ else begin {hex, octal, & binary}
|
|||
token.class := intConstant;
|
||||
end; {else}
|
||||
end; {else}
|
||||
if not atEnd then {make sure we read all characters}
|
||||
FlagError(189);
|
||||
if err <> 0 then begin {handle unconvertible pp-numbers}
|
||||
token.class := preprocessingNumber;
|
||||
token.kind := ppnumber;
|
||||
token.errCode := err;
|
||||
end; {if}
|
||||
if saveNumber or (err <> 0) then begin
|
||||
sp := pointer(GMalloc(length(workString)+1));
|
||||
CopyString(pointer(sp), @workString);
|
||||
if saveNumber then begin
|
||||
sp := pointer(GMalloc(length(numString)+1));
|
||||
CopyString(pointer(sp), @numString);
|
||||
token.numString := sp;
|
||||
end; {if}
|
||||
if scanWork then {make sure we read all characters}
|
||||
if ord(workString[0]) <> numIndex then
|
||||
Error(63);
|
||||
end; {DoNumber}
|
||||
|
||||
|
||||
|
|
@ -4580,8 +4573,7 @@ lintErrors :=
|
|||
spaceStr := ' '; {strings used in stringization}
|
||||
quoteStr := '"';
|
||||
{set of classes for numeric constants}
|
||||
numericConstants :=
|
||||
[intConstant,longConstant,longlongConstant,realConstant,preprocessingNumber];
|
||||
numericConstants := [intConstant,longConstant,longlongConstant,realConstant];
|
||||
|
||||
new(mp); {__LINE__}
|
||||
mp^.name := @'__LINE__';
|
||||
|
|
@ -4812,7 +4804,7 @@ repeat
|
|||
else if lch in ['.','0'..'9'] then begin
|
||||
token.name := GetWord;
|
||||
saveNumber := true;
|
||||
DoNumber;
|
||||
DoNumber(true);
|
||||
saveNumber := false;
|
||||
end {else if}
|
||||
else if lch = '"' then
|
||||
|
|
@ -5336,44 +5328,6 @@ var
|
|||
end; {ConcatenateTokenString}
|
||||
|
||||
|
||||
procedure Number;
|
||||
|
||||
{ Scan a preprocessing number token. It is converted to an }
|
||||
{ integer or floating constant if it matches the syntax for }
|
||||
{ one of those, or left as a preprocessing number if not. }
|
||||
|
||||
var
|
||||
numLen: 1..maxint;
|
||||
lastCh: char;
|
||||
|
||||
begin {Number}
|
||||
numLen := 0;
|
||||
lastCh := chr(0);
|
||||
|
||||
while (charKinds[ord(ch)] in [digit,letter,ch_dot])
|
||||
or ((lastCh in ['e','E','p','P'])
|
||||
and (charKinds[ord(ch)] in [ch_plus,ch_dash])) do
|
||||
begin
|
||||
if numLen < 255 then begin
|
||||
numLen := numLen + 1;
|
||||
workString[numLen] := ch;
|
||||
end {if}
|
||||
else
|
||||
numLen := 256;
|
||||
lastCh := ch;
|
||||
NextCh;
|
||||
end; {while}
|
||||
if numLen = 256 then begin
|
||||
if not skipping then
|
||||
Error(131);
|
||||
numLen := 1;
|
||||
workString[1] := '0';
|
||||
end; {if}
|
||||
workString[0] := chr(numLen);
|
||||
DoNumber;
|
||||
end; {Number}
|
||||
|
||||
|
||||
begin {NextToken}
|
||||
if ifList = nil then {do pending EndInclude calls}
|
||||
while includeCount <> 0 do begin
|
||||
|
|
@ -5707,7 +5661,7 @@ case charKinds[ord(ch)] of
|
|||
|
||||
ch_dot : begin {tokens that start with '.'}
|
||||
if charKinds[ord(PeekCh)] = digit then
|
||||
Number
|
||||
DoNumber(false)
|
||||
else begin
|
||||
NextCh;
|
||||
if (ch = '.') and (PeekCh = '.') then begin
|
||||
|
|
@ -5920,7 +5874,7 @@ case charKinds[ord(ch)] of
|
|||
end;
|
||||
|
||||
digit : {numeric constants}
|
||||
Number;
|
||||
DoNumber(false);
|
||||
|
||||
ch_other: begin {other non-whitespace char (pp-token)}
|
||||
token.kind := otherch;
|
||||
|
|
@ -5978,20 +5932,10 @@ if printMacroExpansions then
|
|||
if not suppressMacroExpansions then
|
||||
if not suppressPrint then
|
||||
PrintToken(token); {print the token stream}
|
||||
if token.kind = otherch then begin
|
||||
if token.kind = otherch then
|
||||
if not (skipping or preprocessing or suppressMacroExpansions)
|
||||
or doingPPExpression then
|
||||
Error(1);
|
||||
end {if}
|
||||
else if token.kind = ppNumber then
|
||||
if not (skipping or preprocessing or suppressMacroExpansions)
|
||||
or doingPPExpression then begin
|
||||
Error(token.errCode);
|
||||
token.kind := intconst;
|
||||
token.class := intConstant;
|
||||
token.ival := 0;
|
||||
token.numString := @'0';
|
||||
end; {if}
|
||||
end; {NextToken}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -309,8 +309,6 @@ charSym start single character symbols
|
|||
enum (barbarop,pluseqop,minuseqop,asteriskeqop,slasheqop)
|
||||
enum (percenteqop,ltlteqop,gtgteqop,andeqop,caroteqop)
|
||||
enum (bareqop,poundpoundop,dotdotdotsy)
|
||||
enum (ppnumber) preprocessing number
|
||||
enum (otherch) other non-whitespace char
|
||||
enum (eolsy,eofsy) control characters
|
||||
enum (typedef) user types
|
||||
! converted operations
|
||||
|
|
@ -468,7 +466,6 @@ icp start in-coming priority for expression
|
|||
dc i1'3' bareqop
|
||||
dc i1'200' poundpoundop
|
||||
dc i1'200' dotdotdotsy
|
||||
dc i1'200' ppnumber
|
||||
dc i1'200' otherch
|
||||
dc i1'200' eolsy
|
||||
dc i1'200' eofsy
|
||||
|
|
@ -647,7 +644,6 @@ isp start in stack priority for expression
|
|||
dc i1'2' bareqop
|
||||
dc i1'0' poundpoundop
|
||||
dc i1'0' dotdotdotsy
|
||||
dc i1'0' ppnumber
|
||||
dc i1'0' otherch
|
||||
dc i1'0' eolsy
|
||||
dc i1'0' eofsy
|
||||
|
|
|
|||
|
|
@ -28,7 +28,6 @@
|
|||
{1} c99desinit.c
|
||||
{1} c99printfa.c
|
||||
{1} c99strtold.c
|
||||
{1} c99ppnum.c
|
||||
{1} c11generic.c
|
||||
{1} c11align.c
|
||||
{1} c11noret.c
|
||||
|
|
|
|||
|
|
@ -1,36 +0,0 @@
|
|||
/*
|
||||
* Test handling of preprocessing numbers.
|
||||
*
|
||||
* Most of this applies to C89, but hex float and long long are specific to
|
||||
* C99 and later.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#define COMBINE3(a,b,c) a##b##c
|
||||
#define STRINGIZE(x) #x
|
||||
|
||||
int main(void) {
|
||||
if (COMBINE3(123,.,456) != 123.456)
|
||||
goto Fail;
|
||||
if (COMBINE3(1.,08,999999999999999999999999999999999)
|
||||
!= 1.08999999999999999999999999999999999)
|
||||
goto Fail;
|
||||
if (COMBINE3(0x,AB,09) != 0xAB09)
|
||||
goto Fail;
|
||||
if (strcmp(STRINGIZE(.1xyzp+), ".1xyzp+") != 0)
|
||||
goto Fail;
|
||||
if (strcmp(STRINGIZE(0xaBcD), "0xaBcD") != 0)
|
||||
goto Fail;
|
||||
if (strcmp(STRINGIZE(089ae-.), "089ae-.") != 0)
|
||||
goto Fail;
|
||||
if (sizeof(COMBINE3(123,L,L)) < sizeof(long long))
|
||||
goto Fail;
|
||||
|
||||
printf ("Passed Conformance Test c99ppnum\n");
|
||||
return 0;
|
||||
|
||||
Fail:
|
||||
printf ("Failed Conformance Test c99ppnum\n");
|
||||
}
|
||||
4
cc.notes
4
cc.notes
|
|
@ -1624,10 +1624,6 @@ If you use #pragma debug 0x0010 to enable stack check debug code, the compiler w
|
|||
|
||||
17. Incorrect code could be generated in certain circumstances where a long long or unsigned long long member of a structure or array was accessed via a pointer.
|
||||
|
||||
18. The ORCA/C preprocessor now allows for preprocessing number tokens that do not match the syntax of an integer or floating constant (e.g. 08Ae-.x). If any such tokens remain after preprocessing, an error will still be reported. Note that this means that code like 0x3e+1 is now treated as a single token that is invalid if it remains after preprocessing, rather than as three tokens that form a valid expression; if you want it to be interpreted as three tokens, you must include whitespace before the +.
|
||||
|
||||
19. When numeric tokens beginning with . were used as operands to the ## preprocessing operator, they behaved as if they started with a leading 0, which could lead to an incorrect result (e.g. 123##.456 became 1230.456).
|
||||
|
||||
-- Bugs from C 2.1.1 B3 that have been fixed in C 2.2.0 ---------------------
|
||||
|
||||
1. There were various bugs that could cause incorrect code to be generated in certain cases. Some of these were specific to certain optimization passes, alone or in combination.
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user