Ignore:
Timestamp:
Oct 21, 2010, 1:20:57 PM (15 years ago)
Author:
george
Message:
  • Enhanced: Tokenizerm, parsing of record type, generation C code for record type.
  • Added: Logging of debug information.
Location:
branches/Transpascal/Compiler
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • branches/Transpascal/Compiler/Analyze/UParser.pas

    r74 r76  
    1010
    1111type
    12   TOnErrorMessage = procedure(Text: string; Position: TPoint; FileName: string) of object;
     12  TErrorMessageEvent = procedure(Text: string; Position: TPoint; FileName: string) of object;
     13  TDebugLogEvent = procedure(Text: string) of object;
    1314
    1415  TParserState = (psNone, psIdentifier, psConstantNumber, psConstantString,
    1516    psOperator, psEndOfFile, psLineComment, psBlockComment1, psBlockComment2,
    16     psUnknown, psWhiteSpace, psConstantStringEnd);
     17    psUnknown, psWhiteSpace, psConstantStringEnd, psBlockComment1First,
     18    psCompilerDirective, psNoneShift, psConstantHexNumber);
    1719
    1820  TTokenType = (ttNone, ttIdentifier, ttConstantNumber, ttConstantString,
    1921    ttOperator, ttEndOfFile, ttLineComment, ttBlockComment1, ttBlockComment2,
    20     ttUnknown, ttWhiteSpace);
     22    ttUnknown, ttWhiteSpace, ttCompilerDirective);
    2123
    2224  TToken = class
    … …  
    3133  private
    3234    FFileName: string;
    33     FOnErrorMessage: TOnErrorMessage;
     35    FOnDebugLog: TDebugLogEvent;
     36    FOnErrorMessage: TErrorMessageEvent;
    3437    FNextToken: string;
    3538    FNextTokenType: TTokenType;
    … …  
    4952    destructor Destroy; override;
    5053    function IsAlphanumeric(Character: char): boolean;
     54    function IsNumeric(Character: char): boolean;
     55    function IsHex(Character: char): boolean;
    5156    function IsWhiteSpace(Character: char): boolean;
    5257    function IsAlphabetic(Character: char): boolean;
    … …  
    6065    procedure ErrorMessage(const Text: string; const Arguments: array of const;
    6166      TokenOffset: Integer);
    62     property OnErrorMessage: TOnErrorMessage read FOnErrorMessage write FOnErrorMessage;
     67    property OnErrorMessage: TErrorMessageEvent read FOnErrorMessage write FOnErrorMessage;
     68    property OnDebugLog: TDebugLogEvent read FOnDebugLog write FOnDebugLog;
    6369    procedure Process;
     70    procedure Log(Text: string);
    6471    property FileName: string read FFileName write FFileName;
    6572  end;
    … …  
    8491procedure TBaseParser.Expect(Code: string);
    8592begin
     93  Log('Expect: ' + Code);
    8694  if NextToken <> Code then begin
    8795    ErrorMessage(SExpectedButFound, [Code, NextToken], 0);
    … …  
    112120function TBaseParser.IsAlphanumeric(Character: char): boolean;
    113121begin
    114   Result := IsAlphabetic(Character) or (Character in ['0'..'9']);
     122  Result := IsAlphabetic(Character) or IsNumeric(Character);
     123end;
     124
     125function TBaseParser.IsNumeric(Character: char): boolean;
     126begin
     127  Result := Character in ['0'..'9'];
     128end;
     129
     130function TBaseParser.IsHex(Character: char): boolean;
     131begin
     132  Result := IsNumeric(Character) or (Character in ['A'..'F']);
    115133end;
    116134
    … …  
    179197end;
    180198
     199procedure TBaseParser.Log(Text: string);
     200begin
     201  if Assigned(FOnDebugLog) then
     202    FOnDebugLog(Text);
     203end;
     204
    181205procedure TBaseParser.GetNextToken;
    182206var
    … …  
    204228      end;
    205229
    206       if FParserState = psNone then begin
     230      if (FParserState = psNone) or (FParserState = psNoneShift) then begin
    207231        TokenCodePosition := CodePosition;
    208232        if IsWhiteSpace(CurrentChar) then
    … …  
    210234        else
    211235        if CurrentChar = '{' then begin
    212           FParserState := psBlockComment1;
     236          FParserState := psBlockComment1First;
    213237        end else
    214238        if CurrentChar = '''' then begin
    215239          FParserState := psConstantString;
     240        end else
     241        if CurrentChar = '$' then begin
     242          FParserState := psConstantHexNumber;
    216243        end else
    217244        if CurrentChar in SpecChar then begin
    … …  
    219246          FNextToken := FNextToken + CurrentChar;
    220247        end else
    221         if IsAlphanumeric(CurrentChar) then begin
     248        if IsAlphabetic(CurrentChar) then begin
    222249          FParserState := psIdentifier;
    223250          FNextToken := FNextToken + CurrentChar;
     251        end else
     252        if IsNumeric(CurrentChar) then begin
     253          FPArserSTate := psConstantNumber;
     254          FNextToken := FNextToken + CurrentChar;
    224255        end else FParserState := psUnknown;
    225256      end else
    226257      if FParserState = psLineComment then begin
    227258        if (CurrentChar = #13) or (CurrentChar = #10) then
     259          FParserState := psNoneShift;
     260      end else
     261      if FParserState = psBlockComment1First then begin
     262        if CurrentChar = '$' then FParserState := psCompilerDirective
     263        else FParserSTate := psBlockComment1;
     264      end else
     265      if FParserState = psBlockComment1 then begin
     266        if (CurrentChar = '}') then begin
     267          FParserState := psNoneShift;
     268        end;
     269      end else
     270      if FParserState = psCompilerDirective then begin
     271        if (CurrentChar = '}') then begin
    228272          FParserState := psNone;
    229       end else
    230       if FParserState = psBlockComment1 then begin
    231         if (CurrentChar = '}') then
    232           FParserState := psNone;
     273          FNextTokenType := ttCompilerDirective;
     274          Break;
     275        end;
    233276      end else
    234277      if FParserState = psBlockComment2 then begin
    235278        if (PreviousChar = '*') and (CurrentChar = ')') then
    236           FParserState := psNone;
     279          FParserState := psNoneShift;
    237280      end else
    238281      if FParserState = psConstantString then
    … …  
    249292        FNextTokenType := ttConstantString;
    250293        Break;
     294      end else
     295      if FParserState = psConstantHexNumber then
     296      begin
     297        if not IsHex(CurrentChar) then begin
     298          FParserState := psNone;
     299          FNextTokenType := ttConstantNumber;
     300          Break;
     301        end else FNextToken := FNextToken + CurrentChar;
     302      end else
     303      if FParserState = psConstantNumber then
     304      begin
     305        if not IsNumeric(CurrentChar) then begin
     306          FParserState := psNone;
     307          FNextTokenType := ttConstantNumber;
     308          Break;
     309        end else FNextToken := FNextToken + CurrentChar;
    251310      end else
    252311      if FParserState = psOperator then
    … …  
    281340      if FParserState = psIdentifier then
    282341      begin
    283         if not IsAlphanumeric(CurrentChar) then begin
     342        if (not IsAlphanumeric(CurrentChar)) and (CurrentChar <> '_') then begin
    284343          FNextTokenType := ttIdentifier;
    285344          Break;
    … …  
    311370    Inc(TokenIndex);
    312371  end else Result := '';
     372  Log('ReadCode: ' + Result);
    313373end;
    314374
    … …  
    318378    Result := TToken(Tokens[TokenIndex]).Token;
    319379  end else Result := '';
     380  Log('NextToken: ' + Result);
    320381end;
    321382

  • branches/Transpascal/Compiler/Analyze/UPascalParser.pas

    r75 r76  
    3737    procedure ParseVariable(SourceCode: TVariable; Exported: Boolean = False);
    3838    procedure ParseConstantList(SourceCode: TConstantList; Exported: Boolean = False);
    39     procedure ParseTypeList(SourceCode: TTypeList; Exported: Boolean = False);
     39    procedure ParseTypeList(SourceCode: TTypeList; Exported: Boolean = False;
     40      AssignSymbol: string = '=');
    4041    function ParseType(TypeList: TTypeList; ExpectName: Boolean = True; AssignSymbol: string = '='): TType;
    4142    function ParseTypeEnumeration(TypeList: TTypeList; Name: string): TType;
    … …  
    7172    Parser := TPascalParser.Create;
    7273    Parser.SourceCodeText := TStringList.Create;
     74    Parser.OnDebugLog := OnDebugLog;
    7375    Parser.ProgramCode := ProgramCode;
    7476    Parser.OnGetSource := OnGetSource;
    … …  
    224226            //  TExpression(SubItems[1]).Value[I - 1] := Byte(Identifier[I]);
    225227          end else begin
    226             TExpression(SubItems[1]).Value := StrToInt(Identifier);
     228            TExpression(SubItems[1]).Value := Identifier;
    227229          end;
    228230        end;
    … …  
    330332    end else
    331333    if NextToken = ';' then
     334      Result := nil
    332335    else begin
    333336      Result := nil;
    … …  
    565568
    566569        // Parse function result type
    567         if HaveResult then
    568         begin
     570        if HaveResult then begin
    569571          Expect(':');
    570572          TypeName := ReadCode;
    571573          NewValueType := Parent.Types.Search(TypeName);
    572574          if not Assigned(NewValueType) then
    573             ErrorMessage(SUndefinedType, [TypeName], -1)
    574           else
     575            ErrorMessage(SUndefinedType, [TypeName], -1);
     576(*          else
    575577          begin
    576578            ResultType := NewValueType;
    … …  
    581583              ValueType := NewValueType;
    582584            end;
    583           end;
     585          end;  *)
    584586        end;
    585587      end;
    … …  
    723725      end else
    724726        ErrorMessage(SRedefineIdentifier, [ConstantName], -1);
    725       Expect(':');
    726       TypeName := ReadCode;
    727       NewValueType := Parent.Types.Search(TypeName);
     727      if NextToken = ':' then begin
     728        Expect(':');
     729        TypeName := ReadCode;
     730        NewValueType := Parent.Types.Search(TypeName);
     731      end;
    728732      Expect('=');
    729733      ConstantValue := ReadCode;
    … …  
    747751{ TParserTypeList }
    748752
    749 procedure TPascalParser.ParseTypeList(SourceCode: TTypeList; Exported: Boolean = False);
     753procedure TPascalParser.ParseTypeList(SourceCode: TTypeList;
     754  Exported: Boolean = False; AssignSymbol: string = '=');
    750755var
    751756  NewType: TType;
    … …  
    754759  begin
    755760    while IsIdentificator(NextToken) do begin
    756       NewType := ParseType(SourceCode);
     761      NewType := ParseType(SourceCode, True, AssignSymbol);
    757762      if Assigned(NewType) then begin
    758763        NewType.Parent := SourceCode;
    … …  
    766771{ TParserType }
    767772
    768 function TPascalParser.ParseType(TypeList: TTypeList; ExpectName: Boolean = True; AssignSymbol: string = '='): TType;
     773function TPascalParser.ParseType(TypeList: TTypeList; ExpectName: Boolean = True;
     774  AssignSymbol: string = '='): TType;
    769775var
    770776  Name: string;
    … …  
    778784    end;
    779785    if NextToken = '(' then begin
     786      // Enumeration
    780787      Result := ParseTypeEnumeration(TypeList, Name);
    781788    end else
    … …  
    817824    end else
    818825    if NextToken = '^' then begin
     826      // Pointer
    819827      Expect('^');
    820828      Result := TTypePointer.Create;
    … …  
    824832    end else
    825833    if NextToken = 'type' then begin
     834      // Buildin base type construction
    826835      Expect('type');
    827836      Result := TTypeInherited.Create;
    … …  
    834843      end else TTypeInherited(Result).UsedType := nil;
    835844    end else begin
     845      // Use existed type
    836846      TypeName := ReadCode;
    837847      if ExpectName then begin
    … …  
    890900  SectionType := stVar;
    891901  Visibility := tvPublic;
    892       Expect('record');
    893       Result := TTypeRecord.Create;
    894       TTypeRecord(Result).Parent := TypeList;
    895       TTypeRecord(Result).CommonBlock.Parent := TypeList.Parent;
    896       TType(Result).Name := Name;
    897       while (NextToken <> 'end') and (NextTokenType <> ttEndOfFile) do
    898       begin
    899         if NextToken = 'public' then begin
    900           Expect('public');
    901           Visibility := tvPublic;
    902         end else
    903         if NextToken = 'private' then begin
    904           Expect('private');
    905           Visibility := tvPrivate;
    906         end else
    907         if NextToken = 'published' then begin
    908           Expect('published');
    909           Visibility := tvPublished;
    910         end else
    911         if NextToken = 'protected' then begin
    912           Expect('protected');
    913           Visibility := tvProtected;
    914         end else
    915         if NextToken = 'var' then begin
    916           Expect('var');
    917           SectionType := stVar
    918         end else
    919         if NextToken = 'const' then begin
    920           Expect('const');
    921           SectionType := stConst
    922         end else
    923         if NextToken = 'type' then begin
    924           Expect('type');
    925           SectionType := stType;
    926         end;
    927 
    928         if SectionType = stVar then begin
    929           if NextToken = 'procedure' then
    930             ParseFunctionList(TTypeRecord(Result).CommonBlock.Functions, True)
    931           else if NextToken = 'function' then
    932             ParseFunctionList(TTypeRecord(Result).CommonBlock.Functions, True)
    933           else begin
     902  Expect('record');
     903  Result := TTypeRecord.Create;
     904  TTypeRecord(Result).Parent := TypeList;
     905  TTypeRecord(Result).CommonBlock.Parent := TypeList.Parent;
     906  TType(Result).Name := Name;
     907  while (NextToken <> 'end') and (NextTokenType <> ttEndOfFile) do begin
     908    if NextToken = 'public' then begin
     909      Expect('public');
     910      Visibility := tvPublic;
     911    end else
     912    if NextToken = 'private' then begin
     913      Expect('private');
     914      Visibility := tvPrivate;
     915    end else
     916    if NextToken = 'published' then begin
     917      Expect('published');
     918      Visibility := tvPublished;
     919    end else
     920    if NextToken = 'protected' then begin
     921      Expect('protected');
     922      Visibility := tvProtected;
     923    end else
     924    if NextToken = 'var' then begin
     925      Expect('var');
     926      SectionType := stVar
     927    end else
     928    if NextToken = 'const' then begin
     929      Expect('const');
     930      SectionType := stConst
     931    end else
     932    if NextToken = 'type' then begin
     933      Expect('type');
     934      SectionType := stType;
     935    end else
     936    if NextToken = 'procedure' then
     937      ParseFunctionList(TTypeRecord(Result).CommonBlock.Functions, True)
     938    else if NextToken = 'function' then
     939      ParseFunctionList(TTypeRecord(Result).CommonBlock.Functions, True)
     940    else begin
     941      if SectionType = stVar then begin
     942          if IsIdentificator(NextToken) then
    934943            ParseVariableList(TTypeRecord(Result).CommonBlock.Variables, True)
    935             //TTypeRecord(Result).CommonBlock.Types.Add(ParseType(TypeList, True, ':'));
    936             //TType(TTypeRecord(Result).CommonBlock.Types.Last).Visibility := Visibility;
    937           end;                                                                          ParseVariableList(TTypeRecord(Result).CommonBlock.Variables)
    938         end
    939         else if SectionType = stConst then
    940           ParseConstantList(TTypeRecord(Result).CommonBlock.Constants, True)
    941         else if SectionType = stType then
    942           ParseTypeList(TTypeRecord(Result).CommonBlock.Types, True);
    943       end;
    944       Expect('end');
     944            else ReadCode;
     945          //TTypeRecord(Result).CommonBlock.Types.Add(ParseType(TypeList, True, ':'));
     946          //TType(TTypeRecord(Result).CommonBlock.Types.Last).Visibility := Visibility;
     947      end
     948      else if SectionType = stConst then
     949        ParseConstantList(TTypeRecord(Result).CommonBlock.Constants, True)
     950      else if SectionType = stType then
     951        ParseTypeList(TTypeRecord(Result).CommonBlock.Types, True, '=');
     952    end;
     953  end;
     954  Expect('end');
    945955end;
    946956

  • branches/Transpascal/Compiler/Produce/UProducerC.pas

    r75 r76  
    1919    function TranslateType(Name: string): string;
    2020    function TranslateOperator(Name: string): string;
    21     procedure Emit(AText: string; NewLine: Boolean = True);
     21    procedure Emit(AText: string);
     22    procedure EmitLn(AText: string = '');
    2223    procedure GenerateUses(UsedModules: TUsedModuleList);
    2324    procedure GenerateModule(Module: TModule);
    … …  
    2728    procedure GenerateTypes(Types: TTypeList);
    2829    procedure GenerateProgram(ProgramBlock: TProgram);
    29     procedure GenerateFunctions(Functions: TFunctionList);
     30    procedure GenerateFunctions(Functions: TFunctionList;
     31      Prefix: string = '');
    3032    procedure GenerateBeginEnd(BeginEnd: TBeginEnd);
    3133    procedure GenerateVariableList(VariableList: TVariableList);
    … …  
    9496end;
    9597
    96 procedure TProducerC.Emit(AText: string; NewLine: Boolean = True);
     98procedure TProducerC.EmitLn(AText: string = '');
     99begin
     100  Emit(AText);
     101  TextSource.Add('');
     102end;
     103
     104procedure TProducerC.Emit(AText: string);
    97105begin
    98106  with TextSource do begin
    … …  
    101109      Strings[Count - 1] := Strings[Count - 1] + DupeString(' ', IndentationLength * Indetation);
    102110    Strings[Count - 1] := Strings[Count - 1] + AText;
    103     if NewLine then Add('');
    104111  end;
    105112end;
    … …  
    111118  for I := 0 to UsedModules.Count - 1 do
    112119    if Dialect = pdDynamicC then
    113       Emit('#use "' + TUsedModule(UsedModules[I]).Name + '.lib"')
    114       else Emit('#include "' + TUsedModule(UsedModules[I]).Name + '.h"');
    115   Emit('');
     120      EmitLn('#use "' + TUsedModule(UsedModules[I]).Name + '.lib"')
     121      else EmitLn('#include "' + TUsedModule(UsedModules[I]).Name + '.h"');
     122  EmitLn;
    116123end;
    117124
    118125procedure TProducerC.GenerateModule(Module: TModule);
    119126begin
    120   if Dialect = pdDynamicC then Emit('#use "platform.lib"')
    121     else Emit('#include "platform.h"');
    122   Emit('');
     127  if Dialect = pdDynamicC then EmitLn('#use "platform.lib"')
     128    else EmitLn('#include "platform.h"');
     129  EmitLn;
    123130  if Module is TModuleProgram then begin
    124131    TModuleProgram(Module).Body.Name := 'main';
    … …  
    149156end;
    150157
    151 procedure TProducerC.GenerateFunctions(Functions: TFunctionList);
     158procedure TProducerC.GenerateFunctions(Functions: TFunctionList;
     159  Prefix: string = '');
    152160var
    153161  I: Integer;
    … …  
    157165  for I := 0 to Functions.Count - 1 do
    158166  with TFunction(Functions[I]) do
    159   if not System then
    160   begin
    161     if HaveResult then Line := TranslateType(ResultType.Name) + ' '
     167  if not System then begin
     168    if HaveResult and Assigned(ResultType) then Line := TranslateType(ResultType.Name) + ' '
    162169      else Line := 'void ';
    163     Line := Line + Name + '(';
     170    Line := Line + Prefix + Name + '(';
    164171    if Parameters.Count > 0 then
    165172    for J := 0 to Parameters.Count - 1 do begin
    … …  
    169176    end;
    170177    Line := Line + ')';
    171     Emit(Line);
     178    EmitLn(Line);
    172179    GenerateBeginEnd(Code);
    173     Emit('');
     180    EmitLn;
    174181  end;
    175182end;
    … …  
    179186  I: Integer;
    180187begin
    181   Emit('{');
     188  EmitLn('{');
    182189  Inc(Indetation);
    183190
    … …  
    192199
    193200  Dec(Indetation);
    194   Emit('}');
     201  EmitLn('}');
    195202end;
    196203
    … …  
    201208  for I := 0 to VariableList.Count - 1 do
    202209    GenerateVariable(TVariable(VariableList[I]));
    203 //  Emit('');
     210//  EmitLn;
    204211end;
    205212
    … …  
    207214begin
    208215  with Variable do
    209     Emit(TranslateType(ValueType.Name) + ' ' + Name + ';');
     216    EmitLn(TranslateType(ValueType.Name) + ' ' + Name + ';');
    210217end;
    211218
    … …  
    222229procedure TProducerC.GenerateWhileDo(WhileDo: TWhileDo);
    223230begin
    224   Emit('while (' + GenerateExpression(WhileDo.Condition) + ')');
    225   GenerateCommand(WhileDo.Command);
     231  EmitLn('while (' + GenerateExpression(WhileDo.Condition) + ')');
     232  if Assigned(WhileDo.Command) then GenerateCommand(WhileDo.Command);
    226233end;
    227234
    … …  
    229236begin
    230237  with ForToDo do begin
    231     Emit('for(' + ControlVariable.Name + ' = ' +
     238    if Assigned(ControlVariable) then
     239    EmitLn('for(' + ControlVariable.Name + ' = ' +
    232240      GenerateExpression(Start) + '; ' + ControlVariable.Name + ' < ' +
    233241      GenerateExpression(Stop) + '; ' + ControlVariable.Name + '++)');
    … …  
    238246procedure TProducerC.GenerateIfThenElse(IfThenElse: TIfThenElse);
    239247begin
    240   Emit('if(' + GenerateExpression(IfThenElse.Condition) + ')');
     248  EmitLn('if(' + GenerateExpression(IfThenElse.Condition) + ')');
    241249  GenerateCommand(IfThenElse.Command);
    242250  if Assigned(IfThenElse.ElseCommand) then begin
    243     Emit('else ');
     251    EmitLn('else ');
    244252    GenerateCommand(IfThenElse.ElseCommand);
    245253  end;
    … …  
    248256procedure TProducerC.GenerateAssignment(Assignment: TAssignment);
    249257begin
    250   if Assignment.Target.Name = 'Result' then Emit('return(' + GenerateExpression(Assignment.Source) + ');')
    251     else Emit(Assignment.Target.Name + ' = ' + GenerateExpression(Assignment.Source) + ';');
     258  if Assignment.Target.Name = 'Result' then EmitLn('return(' + GenerateExpression(Assignment.Source) + ');')
     259    else EmitLn(Assignment.Target.Name + ' = ' + GenerateExpression(Assignment.Source) + ';');
    252260end;
    253261
    … …  
    266274    end;
    267275    Line := Line + ');';
    268     Emit(Line);
     276    EmitLn(Line);
    269277  end;
    270278end;
    … …  
    302310    GenerateTypes(Types);
    303311    GenerateFunctions(Functions);
    304     Emit('void ' + Name + '()');
     312    EmitLn('void ' + Name + '()');
    305313    GenerateBeginEnd(Code);
    306314  end;
    … …  
    313321  if Assigned(AType) then begin
    314322  if AType is TTypeRecord then begin
    315     Emit('struct');
    316     Emit('{');
     323    EmitLn('struct');
     324    EmitLn('{');
    317325    Inc(Indetation);
    318326    GenerateVariableList(TTypeRecord(AType).CommonBlock.Variables);
    319327    Dec(Indetation);
    320     Emit('} ' + TranslateType(AType.Name), False);
     328    EmitLn('} ' + TranslateType(AType.Name) + ';');
     329    EmitLn;
     330    GenerateFunctions(TTypeRecord(AType).CommonBlock.Functions, AType.Name + '_');
    321331  end else
    322332  if AType is TTypeArray then begin
    323333    GenerateType(TTypeArray(AType).ItemType);
    324     Emit('* ', False);
     334    EmitLn('* ');
    325335
    326336(*    if Assigned(TTypeArray(AType).IndexType) then begin
    327       Emit(AType.Name + '[', False);
    328       Emit('[', False);
     337      Emit(AType.Name + '[');
     338      Emit('[');
    329339      GenerateType(TTypeArray(AType).IndexType);
    330       Emit(']', False);
    331     end;
    332     Emit(' of ', False);
     340      Emit(']');
     341    end;
     342    Emit(' of ');
    333343    if Assigned(TTypeArray(AType).ItemType) then*)
    334     Emit(TranslateType(AType.Name), False);
     344    Emit(TranslateType(AType.Name));
     345  end else
     346  if AType is TTypePointer then begin
     347    if Assigned(AType.UsedType) then begin
     348      Emit(AType.UsedType.Name);
     349      Emit(' *');
     350    end;
     351    Emit(TranslateType(AType.Name));
    335352  end else begin
    336353    if Assigned(AType.UsedType) then begin
    337354      //GenerateType(AType.UsedType);
    338       Emit(AType.UsedType.Name, False);
    339       Emit(' ', False);
    340     end;
    341     Emit(TranslateType(AType.Name), False);
     355      Emit(AType.UsedType.Name);
     356      Emit(' ');
     357    end;
     358    Emit(TranslateType(AType.Name));
    342359  end;
    343360  end;
    … …  
    353370    with TType(Types[I]) do
    354371    if (not System) then begin
    355       Emit('typedef ', False);
     372      Emit('typedef ');
    356373      GenerateType(TType(Types[I]));
    357       Emit(';');
     374      EmitLn(';');
    358375    end;
    359376    Dec(Indetation);
    360     Emit('');
    361   end;
    362 end;
    363 
    364 
     377    EmitLn('');
     378  end;
     379end;
    365380
    366381end.

  • branches/Transpascal/Compiler/UCompiler.pas

    r75 r76  
    3232  TCompiler = class
    3333  private
    34     FOnErrorMessage: TOnErrorMessage;
     34    FOnErrorMessage: TErrorMessageEvent;
    3535    procedure ErrorMessage(Text: string; Position: TPoint; FileName: string);
    3636  public
    … …  
    4747    procedure Init;
    4848    procedure Compile(ModuleName: string; Source: TStringList);
    49     property OnErrorMessage: TOnErrorMessage read FOnErrorMessage
     49    property OnErrorMessage: TErrorMessageEvent read FOnErrorMessage
    5050      write FOnErrorMessage;
    5151  end;

  • branches/Transpascal/Compiler/USourceCode.pas

    r73 r76  
    770770      with TUsedModule(UsedModules[I]) do
    771771        with Module do
    772         Result := SearchType(AName, False);
     772          Result := SearchType(AName, False);
    773773      Inc(I);
    774774    end;
Note: See TracChangeset for help on using the changeset viewer.