Subversion Repositories usb_fpga_2_04

{*!

   bmp -- babel macro processor

   Copyright (C) 2009-2014 ZTEX GmbH.

   http://www.ztex.de

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License version 3 as

   published by the Free Software Foundation.

   This program is distributed in the hope that it will be useful, but

   WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

   General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, see http://www.gnu.org/licenses/.

!*}

{$mode objfpc}

unit textbuf;

interface

const maxspathc   = 1024;

      lineInfoPattern : shortstring = '';

type  pdword = ^dword;

      CTextBuf = class;

      CTextBuf = class

        buf          : pchar;    { character buffer }

        li           : pdword;   { line info lineNum shl 12 + file }

        lastbuf,d,d0 : longint;

        allocsize    : longint;  { allocated size }

        last         : CTextBuf;

        killme       : boolean;

        constructor create(var tb:CTextBuf);

        constructor create(var tb:CTextBuf; asize:longint);

        constructor create(var tb:CTextBuf; cb:pchar; lib:pdword; bufsize:longint);

        destructor destroy; override;

        procedure endbuf; virtual;

        end;

      CFileBuf = class(CTextBuf)

        constructor create(var tb:CTextBuf; const fn,ep:ansistring);

        procedure endbuf; override;

       private

        fileNum : longint;

        line    : longint;

        fname   : ansistring;

        errStr  : ansistring; { error trefix }

        stat    : longint;

        f       : file;

        end;

var spath  : array[0..maxspathc-1] of ansistring;

    spathc : longint;

function getFileNum(const fn:ansistring):longint;

function lineInfoStr(li:dword):ansistring;

procedure lineInfoStr(var fo:text; li:dword);

implementation

uses dos,bmpsys;

const textbuf_size = 2048;

{ ********************************************************************* }

{ ****** CTextBuf ***************************************************** }

{ ********************************************************************* }

{ ****** create ******************************************************* }

constructor CTextBuf.create(var tb:CTextBuf);

begin

lastbuf:=-1;

d:=0; d0:=0;

killme:=false;

last:=tb;

tb:=self;

end;

constructor CTextBuf.create(var tb:CTextBuf; asize:longint);

begin

create(tb);

getmem(buf,asize);

getmem(li,asize*4);

allocsize:=asize;

end;

constructor CTextBuf.create(var tb:CTextBuf; cb:pchar; lib:pdword; bufsize:longint);

begin

create(tb);

buf:=cb;

li:=lib;

lastbuf:=bufsize-1;

allocsize:=0;

end;

{ ****** destroy ****************************************************** }

destructor CTextBuf.destroy;

begin

if allocsize>0 then

  begin

  freemem(buf,allocsize);

  freemem(li,allocsize*4);

  end;

end;

{ ****** endbuf ******************************************************* }

procedure CTextBuf.endbuf;

begin

killme:=true;

end;

{ ********************************************************************* }

{ ****** CFileBuf ***************************************************** }

{ ********************************************************************* }

{ ****** create ******************************************************* }

constructor CFileBuf.create(var tb:CTextBuf; const fn,ep:ansistring);

begin

inherited create(tb,textbuf_size);

stat:=0;

pointer(fname):=nil;

fname:=fn;

pointer(errStr):=nil;

errStr:=ep;

fileNum:=-1;

line:=0;

end;

{ ****** endbuf ******************************************************* }

procedure CFileBuf.endbuf;

var i,j  : longint;

    e    : dword;

    sr   : searchrec;

    dir  : dirstr;

    name : namestr;

    ext  : extstr;

    b    : boolean;

begin

lastbuf:=-1;

d0+=d;

d:=0;

killme:=true;

if stat=0 then

  begin

  stat:=1;

  if fname<>'' then

     begin

     j:=-1;

//     write(fname+':  ');

     for i:=0 to spathc-1 do

       begin

//       write(spath[i]+'   ');

       findfirst(spath[i]+fname,$27,sr);

       if doserror=0 then

          begin

          if j<>-1

             then bmp_warning(errstr+'`'+spath[i]+fname+''' found, using `'+spath[j]+fname+'''')

             else j:=i;

          end;

       end;

//     writeln(':  '+spath[j]+fname);

     if j=-1 then

        begin

        bmp_error(errstr+'Can not find file: `'+fname+'''');

        stat:=2;

        exit;

        end;

     fsplit(spath[j]+fname,dir,name,ext);

     b:=true;

     for i:=0 to spathc-1 do

       if dir=spath[i] then b:=false;

     if b then

        begin

        if spathc>=maxspathc

           then bmp_error(errstr+'Maximum amount of search paths reached')

           else begin

                spath[spathc]:=dir;

                spathc+=1;

                end;

        end;

     fileNum:=getFileNum(spath[j]+fname);

     line:=0;

     try

       filemode:=0;

       assign(f,spath[j]+fname);

       reset(f,1);

     except

       bmp_error(errstr+'Can not open file: '+spath[j]+fname);

       fname:='';

       stat:=2;

       end;

     end;

  end;

if stat=1 then

  begin

  if fname=''

     then begin

          lastbuf:=-1;

          while (not(eof(input))) and (lastbuf<textbuf_size-1) do

            begin

            lastbuf+=1;

            read(buf[lastbuf]);

            end;

          end

     else begin

          try

            blockread(f,buf^,textbuf_size,lastbuf);

            lastbuf-=1;

          except

            bmp_error(errstr+'Can read from file: '+fname);

            lastbuf:=-1;

            end;

          end;

  e:=(line shl 12) + fileNum;

  for i:=0 to lastbuf do

    begin

    if buf[i]=#10 then

      begin

      e+=4096;

      line+=1;

      end;

    li[i]:=e;

    end;

  if lastbuf<textbuf_size-1 then

    begin

    stat:=2;

    if fname<>'' then

      begin

      try

        close(f);

      except

        end;

      end;

    end;

  end;

if lastbuf>=0 then killme:=false;

end;

{ ********************************************************************* }

{ ****** FileCache **************************************************** }

{ ********************************************************************* }

const fileCount : longint = 0;

var fileCache : array[0..2047] of ansistring;

{ ****** getFileNum *************************************************** }

function getFileNum(const fn:ansistring):longint;

var i  : longint;

begin

i:=0;

while (i<fileCount) and (i<2047) and (fn<>fileCache[i]) do

  i+=1;

if fn<>fileCache[i] then

  begin

  i:=fileCount and 2047;

  fileCache[i]:=fn;

  fileCount+=1;

  end;

result:=i;

end;

{ ****** lineInfoStr ************************************************* }

function lineInfoStr(li:dword):ansistring;

begin

result:=fileCache[li and 2047]+'('+int2str((li shr 12)+1)+')';

end;

procedure lineInfoStr(var fo:text; li:dword);

var s   : ansistring;

    i,j : longint;

begin

if li and 2048 <> 0 then exit;

pointer(s):=nil;

i:=1;

while i<=length(lineInfoPattern) do

  begin

  if (lineInfoPattern[i]='%') and (i<length(lineInfoPattern))

    then case lineInfoPattern[i+1] of

           '1' : begin

                 for j:=1 to length(fileCache[li and 2047]) do

                   if fileCache[li and 2047][j]='\'

                     then s+='\\'

                     else s+=fileCache[li and 2047][j];

                 i+=1;

                 end;

           '2' : begin

                 s+=int2str(li shr 12);

                 i+=1;

                 end;

           '%' : begin

                 s+='%';

                 i+=1;

                 end;

           else s+='%';

         end

    else s+=lineInfoPattern[i];

  i+=1;

  end;

writeln(fo,s);

end;

procedure initFileCache;

var i : longint;

begin

fileCache[0]:='?';

for i:=1 to 2047 do

  fileCache[i]:=fileCache[0];

end;

begin

initFileCache;

end.