home *** CD-ROM | disk | FTP | other *** search
/ POINT Software Programming / PPROG1.ISO / pascal / swag / strings.swg / 0010_ST-CASE4.PAS.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1993-05-28  |  5.1 KB  |  125 lines
  1. {      Many will recall a series of messages that I posted a few weeks
  2.       ago regarding the Implementation of XLAT in BAsm.
  3.  
  4.       I have revisited it With the idea of using it not For filtering
  5.       but just For up- and low-casing Pascal Strings. I came With a
  6.       pure Assembler Function With a loop of only 4 instructions (TXlat
  7.       in Unit TXLATU.PAS). The acCompanying Program TXLATE1.PAS shows
  8.       examples on how to use TXlat both For up- or low-casing a String.
  9.  
  10.       The intriguing finding was that when I bench-marked it against
  11.       other Assembler Upcasing routines posted in this echo or against
  12.       the one in Hax 144 in PC-Techniques (Vol.3, No.6, Feb 1993, p.40)
  13.       TXlat got to be 20-30% faster! if anyone is interested I could
  14.       upload the benchmarking routines.
  15.  
  16.       So, here is my question: could this possibly be the fastest
  17.       routine For String conversion in Turbo Pascal?
  18.  
  19.       Please note that XLAT has special requirements respect to the
  20.       location of the source and destination buffers as well as the
  21.       translation table. Turbo Pascal memory model places global
  22.       Variables in the data segment wh    local Variables are located in
  23.       the stack segment. The code in TXlat requires that both the table
  24.       and the source buffer be located in the data segment.
  25.  
  26.       Another point of interest is that a Pascal String Variabe (Table) is
  27.       used as the 256-Byte long table required by XLAT.
  28.  
  29.       -Jose- (1:163/513.3)
  30.  
  31.    ============================================================================
  32.  
  33. }
  34.     Unit TXLATU;
  35.  
  36.    {┌───────────────────────────────────────────┐}
  37.    {│Unit TXlatU.PAS by José Campione, Feb.1993.│}
  38.    {│This Unit implements Function TXlat and    │}
  39.    {│declares Variables in the data segment.    │}
  40.    {└───────────────────────────────────────────┘}
  41.  
  42.    Interface
  43.  
  44.    Var
  45.      Source, Table : String;   {┌───────────────────────────────────┐}
  46.                                {│This Forces these Variables to be  │}
  47.                                {│in the data segment. Both Variables│}
  48.                                {│passed to TXlat must be created in │}
  49.                                {│this segment.                      │}
  50.                                {└───────────────────────────────────┘}
  51.  
  52.    Function TXlat(Var Source: String; Var Table: String):String;
  53.  
  54.    Implementation
  55.  
  56.    {┌───────────────────────────────────────────────────────────────────┐}
  57.    {│This Function translates or filters a String as per the Byte values│}
  58.    {│in the Table buffer. It implements the Assembler XLAT instruction. │}
  59.    {└───────────────────────────────────────────────────────────────────┘}
  60.    Function TXlat(Var Source: String; Var Table: String):String; Assembler;
  61.    Asm
  62.               push ds           {preserve data segment}
  63.               lds  bx,table     {load ds:bx With table address}
  64.               lds  si,source    {load ds:si With source address}
  65.                                 {both are in datasegment...}
  66.               les  di,@result   {load es:di With result}
  67.               cld               {si will increment}
  68.               lodsb             {load al With length of source}
  69.               stosb             {store al in es:di}
  70.               mov  cx,ax        {assign length of source to counter}
  71.               or   cx,cx        {if counter = 0}
  72.               jz   @end         {jump to end}
  73.      @filter: lodsb             {load Byte in ax}
  74.               xlat              {tans-xlat-e...}
  75.               stosb             {store it in destination Array}
  76.               loop @filter      {loop back}
  77.         @end: pop ds            {restore data segment}
  78.    end;
  79.  
  80.    end.
  81. {
  82.    ---------------------------------------------------------------------
  83. }
  84.    Program TXLATE1;
  85.  
  86.    {┌───────────────────────────────────────────────┐}
  87.    {│Program TXlate1.PAS by José Campione, Feb.1993.│}
  88.    {│Test Program For Function TXlat in Unit TXlatU │}
  89.    {│It shows how the same Function can be used For │}
  90.    {│up-casing of low-casing a String.              │}
  91.    {└───────────────────────────────────────────────┘}
  92.  
  93.    Uses TXLATU, HAX144U;
  94.  
  95.    Var
  96.      UpSource, LowTable,          {These must be global Variables}
  97.      LowSource, UpTable : String; {created in the data segment   }
  98.      i : Byte;
  99.  
  100.    begin
  101.  
  102.      {┌────────────────────────────────────────────┐}
  103.      {│Set Table For upper Case translation by XLAT│}
  104.      {└────────────────────────────────────────────┘}
  105.      For i:= 0 to 255 do
  106.        if i in [$61..$7A] then UpTable[i]:= Char(i - $20)
  107.          else UpTable[i]:= Char(i);
  108.  
  109.      {┌────────────────────────────────────────────┐}
  110.      {│Set Table For lower Case translation by XLAT│}
  111.      {└────────────────────────────────────────────┘}
  112.      For i:= 0 to 255 do
  113.        if i in [$41..$5A] then LowTable[i]:= Char(i + $20)
  114.          else LowTable[i]:= Char(i);
  115.  
  116.      LowSource:= 'this is a low-Case String to be up-Cased';
  117.      UpSource:= 'THIS IS AN UP-Case String to BE LOW-CaseD';
  118.  
  119.      Writeln(TXlat(LowSource,UpTable));
  120.      Writeln(TXlat(UpSource,LowTable));
  121.  
  122.      ReadLn;
  123.  
  124.    end.
  125.