PopolonY2k rulezz

posts

Write( Var1, Var2, Var3, ...VarN );
Program TestWrite;
Var     strText : String[50];

Begin
  strText := 'And this is a variable.';
  Write( 'This a constant for Write Procedure.', strText );
End.
Write( VarFile, Var1, Var2, Var3, ...VarN );
Program TestPrinter;
Var     strText : String[50];

Begin
  strText := 'And this is a variable.';
  Write( Lst, 'This a constant for Write Procedure.', strText );
End.
Read( Var1, Var2, ..., VarN );
Program TestRead;
Var
      strData : String[255];

Begin
  Write( 'Please type a word' );
  Read( strData );
End;
Read( VarFile, Var1, Var2, Var3, ...VarN );
Program TestReadKbd;
Var
      strData : String[255];

Begin
  Write( 'Please type a word' );
  Read( Kbd, strData );
End;
Var
       fpIntegerFile : File Of Integer;
       fpRealFile    : File Of Real;
       fpStringFile  : File Of String[100];
       fpFileRecord  : File Of Record 
                                 strAddress : String[50];
                                 nNumber    : Integer;
                                 fSalary    : Real;
                               End;
Assign( FileVar : File, strFileName : String );
Reset( FileVar : File );
Rewrite( FileVar : File );
Close( FileVar : File );
Flush( FileVar : File );
(** Sample program to show the power 
  * of Turbo Pascal I/O procedures 
  * by PopolonY2k 2012.
  *)
Program Test_IO;
Var
       fpFile : File Of String[100];

Begin
  Assign( fpFile, 'temp.txt' ); { Assign  the file name to file variable }
  Rewrite( fpFile ); { Create a new file }
  WriteLn( fpFile, 'This is a Test' ); { Write text to file }
  Flush( fpFile ); { Force the buffer dump to disk }
  WriteLn( fpFile, 'Another text to file' );
  Close( fpFile ); { Close the file }
End.
Procedure Seek( fpFile : File; nRec : Integer );
(** This is a sample to show how to make a random access
  * to file, using Seek.
  * by PopolonY2k 2012.
  *)
Program Test_Seek;
Type TMyData = Record
  strName : String[50];
  nAge    : Integer;
End;

Var
       fpFile : File Of TMyData;
       rec    : TMyData;

Begin
  { The first step is write some data to file }
  Assign( fpFile, 'Data.dat' );  { Create the data file }
  Rewrite( fpFile );

  rec.strName := 'PopolonY2k';
  rec.nAge    := 60;
  Write( fpFile, rec );          { Write the first record }
  rec.strName := 'AphroditeY2k';
  rec.nAge    := 40;
  Write( fpFile, rec );          { Write the second record }
  rec.strName := 'HudnosY2k';
  rec.nAge    := 1000;
  Write( fpFile, rec );          { Write the third record }
  Close( fpFile );               { Close the file }

  { Now we start to read the file written previously }

  Assign( fpFile, 'Data.dat' );  { Open the data file }
  Reset( fpFile );

  { Our file has 3 record and the first record is in position 0 zero }
  { Then we start to read the mid record }
  Seek( fpFile, 1 );
  Read( fpFile, rec );
  WriteLn( 'Name -> ', rec.strName );
  WriteLn( 'Age  -> ', rec.nAge );

  { Now reading the last record }
  Seek( fpFile, 2 );
  Read( fpFile, rec );
  WriteLn( 'Name -> ', rec.strName );
  WriteLn( 'Age  -> ', rec.nAge );

  { Now reading the first record }
  Seek( fpFile, 0 );
  Read( fpFile, rec );
  WriteLn( 'Name -> ', rec.strName );
  WriteLn( 'Age  -> ', rec.nAge );
  Close( fpFile );
End.
Function EOF( fpFile : File) : Boolean.
Function EOLn( fpFile : File ) : Boolean;
(** Sample code to show the Turbo Pascal text files related
  * procedures and functions;
  * This sample copy a complete input file to an output file specified
  * by the user;
  * by PopolonY2k 2012;
  *) 
Program Test_TextFiles;

Type TString = String[255];

Var
      fpFileIn,
      fpFileOut  : File Of TString;
      strLine,
      strFileIn,
      strFileOut : TString;

Begin
  WriteLn( 'Please type the input file name' );
  ReadLn( strFileIn );
  WriteLn( 'Please type the output file name' );
  ReadLn( strFileOut );

  Assign( fpFileIn, strFileIn );   { Assign the input and output   }
  Assign( fpFileOut, strFileOut ); { file names to the File handle }
  Reset( fpFileIn );               { variables                     }
  Rewrite( fpFileOut );

  {
    Now the we enter in loop reading the input file until reach the
    end of input file and writing the output to the output file
    previously opened for writing.
  }
  While( Not EOF( fpFileIn ) )  Do  { EOF function sample }
  Begin
    { 
      Here another loop to read the content for each line of input
      file, until the end of line.
    }
    While( Not EOLn( fpFileIn ) ) Do
    Begin
      Read( fpFileIn, strLine );    { Read content from input file }
      Write( fpFileOut, strLine );  { Write content to output file }
    End;
    WriteLn( fpFileOut ); { After read a complete line. We must to }
                          { add a CR/LF at the end of line for the }
                          { output file                            }
  End;
  Close( fpFileIn );      { Close the input and }
  Close( fpFileOut );     { the output files    }
End.
Procedure BlockRead( fpFile : File; 
                     Var Buffer; 
                     nBytes : Integer );
{ Variation of the same procedure }
Procedure BlockRead( fpFile : File; 
                     Var Buffer; 
                     nBytes : Integer; 
                     Var nResult : Integer );
Procedure BlockWrite( fpFile : File;
                      Var Buffer; 
                      nRecs : Integer );
{ Variation of the same procedure }
Procedure BlockWrite( fpFile : File;
                      Var Buffer; 
                      nRecs : Integer; 
                      Var nResult : Integer );
(** Sample code to show the Turbo Pascal direct access low level
  * related procedures and functions;
  * This sample copy a complete input file to an output file specified
  * by the user;
  * by PopolonY2k 2012;
  *) 
Program Test_DirectIO;

Type TString = String[255];
Const ctMaxBuffer : Integer = 1024; { Uses 1024 bytes copy buffer }

Var
      fpFileIn,
      fpFileOut  : File;
      strLine,
      strFileIn,
      strFileOut : TString;
      nRecs     : Integer;
      aBuffer   : Array[0..ctMaxBuffer] Of Byte;

Begin
  WriteLn( 'Please type the input file name' );
  ReadLn( strFileIn );
  WriteLn( 'Please type the output file name' );
  ReadLn( strFileOut );

  Assign( fpFileIn, strFileIn );   { Assign the input and output   }
  Assign( fpFileOut, strFileOut ); { file names to the File handle }
  Reset( fpFileIn );               { variables                     }
  Rewrite( fpFileOut );

  { 
    Start reading the input file until reach the end of file, when
    the BlockRead return zero for the number of records loaded.
  }
  Repeat
    BlockRead( fpFileIn, aBuffer, SizeOf( aBuffer ), nRecs );
    BlockWrite( fpFileOut, aBuffer, nRecs );
  Until( nRecs = 0 );

  Close( fpFileIn );
  Close( fpFileOut );
End.
(** Sample code to show the Turbo Pascal directive for I/O control
  * by the programmer;
  * This sample copy a complete input file to an output file specified
  * by the user;
  * by PopolonY2k 2012;
  *) 
Program Test_IO_Compiler_Directive;

Type TString = String[255];
Const ctMaxBuffer : Integer = 1024; { Uses 1024 bytes copy buffer }

Var
      fpFileIn,
      fpFileOut  : File;
      strLine,
      strFileIn,
      strFileOut : TString;
      nRecs     : Integer;
      aBuffer   : Array[0..ctMaxBuffer] Of Byte;

Begin
  WriteLn( 'Please type the input file name' );
  ReadLn( strFileIn );
  WriteLn( 'Please type the output file name' );
  ReadLn( strFileOut );

  Assign( fpFileIn, strFileIn );   { Assign the input and output   }
  Assign( fpFileOut, strFileOut ); { file names to the File handle }
  {$I-}
  Reset( fpFileIn );               { variables                     }
  {$I+}

  If( IOResult <> 0 )  Then
  Begin
    WriteLn( 'Error to open the input file' );
    Halt;
  End
  Else
  Begin
    {$I-}
    Rewrite( fpFileOut );
    {$I+}
    If( IOResult <> 0 )  Then
    Begin
      WriteLn( 'Error to open the output file' );
      Halt;
    End;
  End;

  { 
    Start reading the input file until reach the end of file, when
    the BlockRead return zero for the number of records loaded.
  }
  Repeat
    BlockRead( fpFileIn, aBuffer, SizeOf( aBuffer ), nRecs );
    BlockWrite( fpFileOut, aBuffer, nRecs );
  Until( nRecs = 0 );

  Close( fpFileIn );
  Close( fpFileOut );
End.

PopolonY2k rulezz

MSXDUMP v0.2 (final) liberado no SourceForge.net

Teste da TV/Monitor SAMSUNG T22B300

MSXDUMP v0.1 liberado no Sourceforge.net

MSX Jaú 2012

MSX JAÚ 2012

MSX ARM – Primeiro teste de hardware.

MSXRio – Attention Please !!!!

A terceira (e última) MSXRio de 2012 será no Dia das Crianças (e no sábado também)!

MSXDUMP vrs 0.0, liberado no SourceForge.net

Turbo Pascal Forever – Input/Output

Grupo de desenvolvimento de software e coisas legais para MSX