← Back to branch summary

~ubuntu-branches/debian/lenny/fpc/lenny

« back to all changes in this revision

Viewing changes to compiler/utils/mkppcreg.pp

  • Committer: Bazaar Package Importer
  • Author(s): Mazen Neifer, Torsten Werner, Mazen Neifer
  • Date: 2008-05-17 17:12:11 UTC
  • mfrom: (3.1.9 intrepid)
  • Revision ID: james.westby@ubuntu.com-20080517171211-9qi33xhd9evfa0kg
Tags: 2.2.0-dfsg1-9
http://bugs.debian.org/477743
[ Torsten Werner ]
* Add Mazen Neifer to Uploaders field.

[ Mazen Neifer ]
* Moved FPC sources into a version dependent directory from /usr/share/fpcsrc
  to /usr/share/fpcsrc/${FPCVERSION}. This allow installing more than on FPC
  release.
* Fixed far call issue in compiler preventing building huge binearies.
  (closes: #477743)
* Updated building dependencies, recomennded and suggested packages.
* Moved fppkg to fp-utils as it is just a helper tool and is not required by
  compiler.

Show diffs side-by-side

added added

removed removed

Lines of Context:
compiler/utils/mkppcreg.pp
1
 
{
2
 
    $Id: mkppcreg.pp,v 1.7 2003/12/16 21:49:47 florian Exp $
3
 
    Copyright (c) 1998-2002 by Peter Vreman and Florian Klaempfl
4
 
 
5
 
    Convert ppcreg.dat to several .inc files for usage with
6
 
    the Free pascal compiler
7
 
 
8
 
    See the file COPYING.FPC, included in this distribution,
9
 
    for details about the copyright.
10
 
 
11
 
    This program is distributed in the hope that it will be useful,
12
 
    but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
14
 
 
15
 
 **********************************************************************}
16
 
program mkppcreg;
17
 
 
18
 
const Version = '1.00';
19
 
      max_regcount = 200;
20
 
 
21
 
var s : string;
22
 
    i : longint;
23
 
    line : longint;
24
 
    regcount:byte;
25
 
    regcount_bsstart:byte;
26
 
    names,
27
 
    regtypes,
28
 
    supregs,
29
 
    numbers,
30
 
    stdnames,
31
 
    gasnames,
32
 
    gssnames,
33
 
    motnames,
34
 
    stabs : array[0..max_regcount-1] of string[63];
35
 
    regnumber_index,
36
 
    std_regname_index,
37
 
    gas_regname_index,
38
 
    mot_regname_index : array[0..max_regcount-1] of byte;
39
 
 
40
 
{$ifndef FPC}
41
 
  procedure readln(var t:text;var s:string);
42
 
  var
43
 
    c : char;
44
 
    i : longint;
45
 
  begin
46
 
    c:=#0;
47
 
    i:=0;
48
 
    while (not eof(t)) and (c<>#10) do
49
 
     begin
50
 
       read(t,c);
51
 
       if c<>#10 then
52
 
        begin
53
 
          inc(i);
54
 
          s[i]:=c;
55
 
        end;
56
 
     end;
57
 
    if (i>0) and (s[i]=#13) then
58
 
     dec(i);
59
 
    s[0]:=chr(i);
60
 
  end;
61
 
{$endif}
62
 
 
63
 
function tostr(l : longint) : string;
64
 
 
65
 
begin
66
 
  str(l,tostr);
67
 
end;
68
 
 
69
 
function readstr : string;
70
 
 
71
 
  var
72
 
     result : string;
73
 
 
74
 
  begin
75
 
     result:='';
76
 
     while (s[i]<>',') and (i<=length(s)) do
77
 
       begin
78
 
          result:=result+s[i];
79
 
          inc(i);
80
 
       end;
81
 
     readstr:=result;
82
 
  end;
83
 
 
84
 
 
85
 
procedure readcomma;
86
 
  begin
87
 
     if s[i]<>',' then
88
 
       begin
89
 
         writeln('Missing "," at line ',line);
90
 
         writeln('Line: "',s,'"');
91
 
         halt(1);
92
 
       end;
93
 
     inc(i);
94
 
  end;
95
 
 
96
 
 
97
 
procedure skipspace;
98
 
 
99
 
  begin
100
 
     while (s[i] in [' ',#9]) do
101
 
       inc(i);
102
 
  end;
103
 
 
104
 
procedure openinc(var f:text;const fn:string);
105
 
begin
106
 
  writeln('creating ',fn);
107
 
  assign(f,fn);
108
 
  rewrite(f);
109
 
  writeln(f,'{ don''t edit, this file is generated from ppcreg.dat }');
110
 
end;
111
 
 
112
 
 
113
 
procedure closeinc(var f:text);
114
 
begin
115
 
  writeln(f);
116
 
  close(f);
117
 
end;
118
 
 
119
 
procedure build_regnum_index;
120
 
 
121
 
var h,i,j,p,t:byte;
122
 
 
123
 
begin
124
 
  {Build the registernumber2regindex index.
125
 
   Step 1: Fill.}
126
 
  for i:=0 to regcount-1 do
127
 
    regnumber_index[i]:=i;
128
 
  {Step 2: Sort. We use a Shell-Metzner sort.}
129
 
  p:=regcount_bsstart;
130
 
  repeat
131
 
    for h:=0 to regcount-p-1 do
132
 
      begin
133
 
        i:=h;
134
 
        repeat
135
 
          j:=i+p;
136
 
          if numbers[regnumber_index[j]]>=numbers[regnumber_index[i]] then
137
 
            break;
138
 
          t:=regnumber_index[i];
139
 
          regnumber_index[i]:=regnumber_index[j];
140
 
          regnumber_index[j]:=t;
141
 
          if i<p then
142
 
            break;
143
 
          dec(i,p);
144
 
        until false;
145
 
      end;
146
 
    p:=p shr 1;
147
 
  until p=0;
148
 
end;
149
 
 
150
 
procedure build_std_regname_index;
151
 
 
152
 
var h,i,j,p,t:byte;
153
 
 
154
 
begin
155
 
  {Build the registernumber2regindex index.
156
 
   Step 1: Fill.}
157
 
  for i:=0 to regcount-1 do
158
 
    std_regname_index[i]:=i;
159
 
  {Step 2: Sort. We use a Shell-Metzner sort.}
160
 
  p:=regcount_bsstart;
161
 
  repeat
162
 
    for h:=0 to regcount-p-1 do
163
 
      begin
164
 
        i:=h;
165
 
        repeat
166
 
          j:=i+p;
167
 
          if stdnames[std_regname_index[j]]>=stdnames[std_regname_index[i]] then
168
 
            break;
169
 
          t:=std_regname_index[i];
170
 
          std_regname_index[i]:=std_regname_index[j];
171
 
          std_regname_index[j]:=t;
172
 
          if i<p then
173
 
            break;
174
 
          dec(i,p);
175
 
        until false;
176
 
      end;
177
 
    p:=p shr 1;
178
 
  until p=0;
179
 
end;
180
 
 
181
 
 
182
 
procedure build_gas_regname_index;
183
 
 
184
 
var h,i,j,p,t:byte;
185
 
 
186
 
begin
187
 
  {Build the registernumber2regindex index.
188
 
   Step 1: Fill.}
189
 
  for i:=0 to regcount-1 do
190
 
    gas_regname_index[i]:=i;
191
 
  {Step 2: Sort. We use a Shell-Metzner sort.}
192
 
  p:=regcount_bsstart;
193
 
  repeat
194
 
    for h:=0 to regcount-p-1 do
195
 
      begin
196
 
        i:=h;
197
 
        repeat
198
 
          j:=i+p;
199
 
          if gasnames[gas_regname_index[j]]>=gasnames[gas_regname_index[i]] then
200
 
            break;
201
 
          t:=gas_regname_index[i];
202
 
          gas_regname_index[i]:=gas_regname_index[j];
203
 
          gas_regname_index[j]:=t;
204
 
          if i<p then
205
 
            break;
206
 
          dec(i,p);
207
 
        until false;
208
 
      end;
209
 
    p:=p shr 1;
210
 
  until p=0;
211
 
end;
212
 
 
213
 
 
214
 
procedure build_mot_regname_index;
215
 
 
216
 
var h,i,j,p,t:byte;
217
 
 
218
 
begin
219
 
  {Build the registernumber2regindex index.
220
 
   Step 1: Fill.}
221
 
  for i:=0 to regcount-1 do
222
 
    mot_regname_index[i]:=i;
223
 
  {Step 2: Sort. We use a Shell-Metzner sort.}
224
 
  p:=regcount_bsstart;
225
 
  repeat
226
 
    for h:=0 to regcount-p-1 do
227
 
      begin
228
 
        i:=h;
229
 
        repeat
230
 
          j:=i+p;
231
 
          if motnames[mot_regname_index[j]]>=motnames[mot_regname_index[i]] then
232
 
            break;
233
 
          t:=mot_regname_index[i];
234
 
          mot_regname_index[i]:=mot_regname_index[j];
235
 
          mot_regname_index[j]:=t;
236
 
          if i<p then
237
 
            break;
238
 
          dec(i,p);
239
 
        until false;
240
 
      end;
241
 
    p:=p shr 1;
242
 
  until p=0;
243
 
end;
244
 
 
245
 
 
246
 
procedure read_ppcreg_file;
247
 
 
248
 
var infile:text;
249
 
 
250
 
begin
251
 
   { open dat file }
252
 
   assign(infile,'ppcreg.dat');
253
 
   reset(infile);
254
 
   while not(eof(infile)) do
255
 
     begin
256
 
        { handle comment }
257
 
        readln(infile,s);
258
 
        inc(line);
259
 
        while (s[1]=' ') do
260
 
         delete(s,1,1);
261
 
        if (s='') or (s[1]=';') then
262
 
          continue;
263
 
 
264
 
        i:=1;
265
 
        names[regcount]:=readstr;
266
 
        readcomma;
267
 
        regtypes[regcount]:=readstr;
268
 
        readcomma;
269
 
        supregs[regcount]:=readstr;
270
 
        readcomma;
271
 
        stdnames[regcount]:=readstr;
272
 
        readcomma;
273
 
        gasnames[regcount]:=readstr;
274
 
        readcomma;
275
 
        gssnames[regcount]:=readstr;
276
 
        readcomma;
277
 
        motnames[regcount]:=readstr;
278
 
        readcomma;
279
 
        stabs[regcount]:=readstr;
280
 
        { Create register number }
281
 
        if supregs[regcount][1]<>'$' then
282
 
          begin
283
 
            writeln('Missing $ before number, at line ',line);
284
 
            writeln('Line: "',s,'"');
285
 
            halt(1);
286
 
          end;
287
 
        numbers[regcount]:=regtypes[regcount]+'0000'+copy(supregs[regcount],2,255);
288
 
        if i<length(s) then
289
 
          begin
290
 
            writeln('Extra chars at end of line, at line ',line);
291
 
            writeln('Line: "',s,'"');
292
 
            halt(1);
293
 
          end;
294
 
        inc(regcount);
295
 
        if regcount>max_regcount then
296
 
          begin
297
 
            writeln('Error: Too much registers, please increase maxregcount in source');
298
 
            halt(2);
299
 
          end;
300
 
     end;
301
 
   close(infile);
302
 
end;
303
 
 
304
 
procedure write_inc_files;
305
 
 
306
 
var
307
 
    norfile,stdfile,motfile,supfile,
308
 
    numfile,stabfile,confile,gasfile,gssfile,
309
 
    rnifile,srifile,mrifile,grifile : text;
310
 
    first:boolean;
311
 
 
312
 
begin
313
 
  { create inc files }
314
 
  openinc(confile,'rppccon.inc');
315
 
  openinc(supfile,'rppcsup.inc');
316
 
  openinc(numfile,'rppcnum.inc');
317
 
  openinc(stdfile,'rppcstd.inc');
318
 
  openinc(gasfile,'rppcgas.inc');
319
 
  openinc(gssfile,'rppcgss.inc');
320
 
  openinc(motfile,'rppcmot.inc');
321
 
  openinc(stabfile,'rppcstab.inc');
322
 
  openinc(norfile,'rppcnor.inc');
323
 
  openinc(rnifile,'rppcrni.inc');
324
 
  openinc(srifile,'rppcsri.inc');
325
 
  openinc(grifile,'rppcgri.inc');
326
 
  openinc(mrifile,'rppcmri.inc');
327
 
  first:=true;
328
 
  for i:=0 to regcount-1 do
329
 
    begin
330
 
      if not first then
331
 
        begin
332
 
          writeln(numfile,',');
333
 
          writeln(stdfile,',');
334
 
          writeln(gasfile,',');
335
 
          writeln(gssfile,',');
336
 
          writeln(motfile,',');
337
 
          writeln(stabfile,',');
338
 
          writeln(rnifile,',');
339
 
          writeln(srifile,',');
340
 
          writeln(grifile,',');
341
 
          writeln(mrifile,',');
342
 
        end
343
 
      else
344
 
        first:=false;
345
 
      writeln(supfile,'RS_',names[i],' = ',supregs[i],';');
346
 
      writeln(confile,'NR_'+names[i],' = ','tregister(',numbers[i],')',';');
347
 
      write(numfile,'tregister(',numbers[i],')');
348
 
      write(stdfile,'''',stdnames[i],'''');
349
 
      write(gasfile,'''',gasnames[i],'''');
350
 
      write(gssfile,'''',gssnames[i],'''');
351
 
      write(motfile,'''',motnames[i],'''');
352
 
      write(stabfile,stabs[i]);
353
 
      write(rnifile,regnumber_index[i]);
354
 
      write(srifile,std_regname_index[i]);
355
 
      write(grifile,gas_regname_index[i]);
356
 
      write(mrifile,mot_regname_index[i]);
357
 
    end;
358
 
  write(norfile,regcount);
359
 
  close(confile);
360
 
  close(supfile);
361
 
  closeinc(numfile);
362
 
  closeinc(stdfile);
363
 
  closeinc(gasfile);
364
 
  closeinc(gssfile);
365
 
  closeinc(motfile);
366
 
  closeinc(stabfile);
367
 
  closeinc(norfile);
368
 
  closeinc(rnifile);
369
 
  closeinc(srifile);
370
 
  closeinc(grifile);
371
 
  closeinc(mrifile);
372
 
  writeln('Done!');
373
 
  writeln(regcount,' registers procesed');
374
 
end;
375
 
 
376
 
 
377
 
begin
378
 
   writeln('Register Table Converter Version ',Version);
379
 
   line:=0;
380
 
   regcount:=0;
381
 
   read_ppcreg_file;
382
 
   regcount_bsstart:=1;
383
 
   while 2*regcount_bsstart<regcount do
384
 
     regcount_bsstart:=regcount_bsstart*2;
385
 
   build_regnum_index;
386
 
   build_std_regname_index;
387
 
   build_gas_regname_index;
388
 
   build_mot_regname_index;
389
 
   write_inc_files;
390
 
end.
391
 
{
392
 
  $Log: mkppcreg.pp,v $
393
 
  Revision 1.7  2003/12/16 21:49:47  florian
394
 
    * fixed ppc compilation
395
 
 
396
 
  Revision 1.6  2003/12/10 22:19:28  florian
397
 
    + short gas register names for smartlinking added
398
 
 
399
 
  Revision 1.5  2003/09/03 20:33:28  peter
400
 
    * fixed sorting of register number
401
 
 
402
 
  Revision 1.4  2003/09/03 19:37:07  peter
403
 
    * powerpc reg update
404
 
 
405
 
  Revision 1.2  2003/09/03 15:55:01  peter
406
 
    * NEWRA branch merged
407
 
 
408
 
  Revision 1.1.2.1  2003/09/02 20:48:22  peter
409
 
    * powerpc registers
410
 
 
411
 
}