TextIO Tutorial

[Dek]

On 25 Apr, 10:01, "HT-Lab" <han...@ht-lab.com> wrote:

"Dek" <daniele.deq...@gmail.com> wrote in message

news:c3686086-6f77-4d96-9498-1c21532af85e@3g2000yqk.googlegroups.com...
On 23 Apr, 19:19, Mike Treseler <mtrese...@gmail.com> wrote:

Dek wrote:
I think I can't do anything better, because I have to simulate how an
FPGA would work on data coming from a detector, that are already
stored in many .txt files.

Now the problem is that such files are thousands and it takes a lot of
time to change manually their name in vhdl code. One idea is to use
Generics, name all data files in a "name.do" file and use "do name.do"
command. Even in this case, however, I have to name files manually one
by one. Do you know if there is a way to read all files in a folder
without nameing them?

Look into using Tcl which if fully integrated with Modelsim. To read a
directory simply use the "glob *" command followed by a "foreach" to handle
each filename. Other useful Tcl Modelsim commands are force/when and examine
(see manual),

Hanswww.ht-lab.com



The same problem, unfortunately, is for writing, since for each in-
file I have to write one out-file.

Thanks

Bye- Nascondi testo citato

- Mostra testo citato -

Thanks all

I think I'll try first the idea of KJ; since I'm just learning VHDL
and ModelSim, I'll leave Tcl for the future.

Thanks again

Bye

Dek

 

[Dek]

On 25 Apr, 02:21, "KJ" <kkjenni...@sbcglobal.net> wrote:

I think I can't do anything better, because I have to simulate how an
FPGA would work on data coming from a detector, that are already
stored in many .txt files.

One could ask how did those files get created in the first place.  Unless
they were generated from an actual detector, then they were artificially
generated in the first place.  Rather than artificially generating data into
text files and then figuring out how to read them into a testbench it is
much more productive to model the detector in the VHDL testbench and totally
bypass file I/O (which is not really one of VHDL's strengths).

But I'll assume though that you have to work with file I/O.

Now the problem is that such files are thousands and it takes a lot of
time to change manually their name in vhdl code. One idea is to use
Generics, name all data files in a "name.do" file and use "do name.do"
command. Even in this case, however, I have to name files manually one
by one.

Not really.  The name.do file can be easily created with a simple directory
listing command
(Windows command line "dir /b >name.do").  That's pretty easy to do.

Do you know if there is a way to read all files in a folder
without nameing them?

I don't.

The same problem, unfortunately, is for writing, since for each in-
file I have to write one out-file.

Once you've read in a line from 'name.do' you've got a unique input file
name.  I would construct a similarly unique output file name by modifying
the input file name in some fashion (say by appending ".out" to the input
file name).

Kevin Jennings

Ok, I'll definitively thank this group in my thesis! Your idea seems
to work, but there is still a little problem:

the name are of different length! If i do like this:
-----------------------------------------------
Architecture...
Begin
process
VARIABLE filename : String (23 downto 1);
-----------------------------------------------
it works until it find a filename of lenght different from 23.

I tried to do something like this:
VARIABLE filename : String;
or
VARIABLE filename : String (natural range<>
but I always get an error message.
Have any suggestion?

Thanks

Dek

 

[Tricky]

On 28 Apr, 14:01, Dek <daniele.deq...@gmail.com> wrote:

On 25 Apr, 02:21, "KJ" <kkjenni...@sbcglobal.net> wrote:



I think I can't do anything better, because I have to simulate how an
FPGA would work on data coming from a detector, that are already
stored in many .txt files.

One could ask how did those files get created in the first place.  Unless
they were generated from an actual detector, then they were artificially
generated in the first place.  Rather than artificially generating data into
text files and then figuring out how to read them into a testbench it is
much more productive to model the detector in the VHDL testbench and totally
bypass file I/O (which is not really one of VHDL's strengths).

But I'll assume though that you have to work with file I/O.

Now the problem is that such files are thousands and it takes a lot of
time to change manually their name in vhdl code. One idea is to use
Generics, name all data files in a "name.do" file and use "do name.do"
command. Even in this case, however, I have to name files manually one
by one.

Not really.  The name.do file can be easily created with a simple directory
listing command
(Windows command line "dir /b >name.do").  That's pretty easy to do.

Do you know if there is a way to read all files in a folder
without nameing them?

I don't.

The same problem, unfortunately, is for writing, since for each in-
file I have to write one out-file.

Once you've read in a line from 'name.do' you've got a unique input file
name.  I would construct a similarly unique output file name by modifying
the input file name in some fashion (say by appending ".out" to the input
file name).

Kevin Jennings

Ok, I'll definitively thank this group in my thesis! Your idea seems
to work, but there is still a little problem:

the name are of different length! If i do like this:
-----------------------------------------------
Architecture...
Begin
process
    VARIABLE filename : String (23 downto 1);
-----------------------------------------------
it works until it find a filename of lenght different from 23.

I tried to do something like this:
VARIABLE filename : String;
or
VARIABLE filename : String (natural range<>
but I always get an error message.
Have any suggestion?

Thanks

Dek

I assume you are reading the string from a line? well, a line is
actually a pointer to a string.

So, assuming you just have 1 filename per line, you can do something
like:

readline(namefile, inline);

FILE_OPEN(f, inline.all, READ_MODE);
DEALLOCATE(inline); --drops the pointer

You could do the same if its not just 1 file name per line, but the
parsing would get more complicated. But the method above means you can
have filenames as long as you want.

 

[Dek]

On 28 Apr, 15:28, Tricky <Trickyh...@gmail.com> wrote:

On 28 Apr, 14:01, Dek <daniele.deq...@gmail.com> wrote:





On 25 Apr, 02:21, "KJ" <kkjenni...@sbcglobal.net> wrote:

I think I can't do anything better, because I have to simulate how an
FPGA would work on data coming from a detector, that are already
stored in many .txt files.

One could ask how did those files get created in the first place.  Unless
they were generated from an actual detector, then they were artificially
generated in the first place.  Rather than artificially generating data into
text files and then figuring out how to read them into a testbench it is
much more productive to model the detector in the VHDL testbench and totally
bypass file I/O (which is not really one of VHDL's strengths).

But I'll assume though that you have to work with file I/O.

Now the problem is that such files are thousands and it takes a lot of
time to change manually their name in vhdl code. One idea is to use
Generics, name all data files in a "name.do" file and use "do name.do"
command. Even in this case, however, I have to name files manually one
by one.

Not really.  The name.do file can be easily created with a simple directory
listing command
(Windows command line "dir /b >name.do").  That's pretty easy to do..

Do you know if there is a way to read all files in a folder
without nameing them?

I don't.

The same problem, unfortunately, is for writing, since for each in-
file I have to write one out-file.

Once you've read in a line from 'name.do' you've got a unique input file
name.  I would construct a similarly unique output file name by modifying
the input file name in some fashion (say by appending ".out" to the input
file name).

Kevin Jennings

Ok, I'll definitively thank this group in my thesis! Your idea seems
to work, but there is still a little problem:

the name are of different length! If i do like this:
-----------------------------------------------
Architecture...
Begin
process
    VARIABLE filename : String (23 downto 1);
-----------------------------------------------
it works until it find a filename of lenght different from 23.

I tried to do something like this:
VARIABLE filename : String;
or
VARIABLE filename : String (natural range<>
but I always get an error message.
Have any suggestion?

Thanks

Dek

I assume you are reading the string from a line? well, a line is
actually a pointer to a string.

So, assuming you just have 1 filename per line, you can do something
like:

readline(namefile, inline);

FILE_OPEN(f, inline.all, READ_MODE);
DEALLOCATE(inline);         --drops the pointer

You could do the same if its not just 1 file name per line, but the
parsing would get more complicated. But the method above means you can
have filenames as long as you want.- Nascondi testo citato

- Mostra testo citato -

Sorry but I didn't get what you mean; When I use the deallocate
command don't I lose all informations pointed by infile? If I
understood right the deallocate command serves to free memory, so if I
write :

DEALLOCATE(inline);

I will free the memory block used to store the contents of infile; how
can I find the same contents in a string whose lenght is not
constrained?

Another question: is there a command to know the lenght of a line?
Because I could do so:

READFILE (infile, inline);
int := LENGHT (inline); -- int already defined as an integer

than i could continue with an IF clause. Unfortunately LENGHT is not
the right keyword.

Thanks again

 

[Dek]

On 28 Apr, 15:28, Tricky <Trickyh...@gmail.com> wrote:

On 28 Apr, 14:01, Dek <daniele.deq...@gmail.com> wrote:





On 25 Apr, 02:21, "KJ" <kkjenni...@sbcglobal.net> wrote:

I think I can't do anything better, because I have to simulate how an
FPGA would work on data coming from a detector, that are already
stored in many .txt files.

One could ask how did those files get created in the first place.  Unless
they were generated from an actual detector, then they were artificially
generated in the first place.  Rather than artificially generating data into
text files and then figuring out how to read them into a testbench it is
much more productive to model the detector in the VHDL testbench and totally
bypass file I/O (which is not really one of VHDL's strengths).

But I'll assume though that you have to work with file I/O.

Now the problem is that such files are thousands and it takes a lot of
time to change manually their name in vhdl code. One idea is to use
Generics, name all data files in a "name.do" file and use "do name.do"
command. Even in this case, however, I have to name files manually one
by one.

Not really.  The name.do file can be easily created with a simple directory
listing command
(Windows command line "dir /b >name.do").  That's pretty easy to do..

Do you know if there is a way to read all files in a folder
without nameing them?

I don't.

The same problem, unfortunately, is for writing, since for each in-
file I have to write one out-file.

Once you've read in a line from 'name.do' you've got a unique input file
name.  I would construct a similarly unique output file name by modifying
the input file name in some fashion (say by appending ".out" to the input
file name).

Kevin Jennings

Ok, I'll definitively thank this group in my thesis! Your idea seems
to work, but there is still a little problem:

the name are of different length! If i do like this:
-----------------------------------------------
Architecture...
Begin
process
    VARIABLE filename : String (23 downto 1);
-----------------------------------------------
it works until it find a filename of lenght different from 23.

I tried to do something like this:
VARIABLE filename : String;
or
VARIABLE filename : String (natural range<>
but I always get an error message.
Have any suggestion?

Thanks

Dek

I assume you are reading the string from a line? well, a line is
actually a pointer to a string.

So, assuming you just have 1 filename per line, you can do something
like:

readline(namefile, inline);

FILE_OPEN(f, inline.all, READ_MODE);
DEALLOCATE(inline);         --drops the pointer

You could do the same if its not just 1 file name per line, but the
parsing would get more complicated. But the method above means you can
have filenames as long as you want.- Nascondi testo citato

- Mostra testo citato -

Sorry but I didn't get what you mean; When I use the deallocate
command don't I lose all informations pointed by inline? If I
understood right the deallocate command serves to free memory, so if
I
write :

DEALLOCATE(inline);


I will free the memory block used to store the contents of infile;
how
can I find the same contents in a string whose lenght is not
constrained?


Another question: is there a command to know the lenght of a line?
Because I could do so:


READFILE (infile, inline);
int := LENGHT (inline); -- int already defined as an integer


than i could continue with an IF clause. Unfortunately LENGHT is not
the right keyword.


Thanks again

 

[Dek]

On 30 Apr, 09:45, Dek <daniele.deq...@gmail.com> wrote:

On 28 Apr, 15:28, Tricky <Trickyh...@gmail.com> wrote:





On 28 Apr, 14:01, Dek <daniele.deq...@gmail.com> wrote:

On 25 Apr, 02:21, "KJ" <kkjenni...@sbcglobal.net> wrote:

I think I can't do anything better, because I have to simulate how an
FPGA would work on data coming from a detector, that are already
stored in many .txt files.

One could ask how did those files get created in the first place.  Unless
they were generated from an actual detector, then they were artificially
generated in the first place.  Rather than artificially generating data into
text files and then figuring out how to read them into a testbench it is
much more productive to model the detector in the VHDL testbench and totally
bypass file I/O (which is not really one of VHDL's strengths).

But I'll assume though that you have to work with file I/O.

Now the problem is that such files are thousands and it takes a lot of
time to change manually their name in vhdl code. One idea is to use
Generics, name all data files in a "name.do" file and use "do name.do"
command. Even in this case, however, I have to name files manually one
by one.

Not really.  The name.do file can be easily created with a simple directory
listing command
(Windows command line "dir /b >name.do").  That's pretty easy to do.

Do you know if there is a way to read all files in a folder
without nameing them?

I don't.

The same problem, unfortunately, is for writing, since for each in-
file I have to write one out-file.

Once you've read in a line from 'name.do' you've got a unique input file
name.  I would construct a similarly unique output file name by modifying
the input file name in some fashion (say by appending ".out" to the input
file name).

Kevin Jennings

Ok, I'll definitively thank this group in my thesis! Your idea seems
to work, but there is still a little problem:

the name are of different length! If i do like this:
-----------------------------------------------
Architecture...
Begin
process
    VARIABLE filename : String (23 downto 1);
-----------------------------------------------
it works until it find a filename of lenght different from 23.

I tried to do something like this:
VARIABLE filename : String;
or
VARIABLE filename : String (natural range<>
but I always get an error message.
Have any suggestion?

Thanks

Dek

I assume you are reading the string from a line? well, a line is
actually a pointer to a string.

So, assuming you just have 1 filename per line, you can do something
like:

readline(namefile, inline);

FILE_OPEN(f, inline.all, READ_MODE);
DEALLOCATE(inline);         --drops the pointer

You could do the same if its not just 1 file name per line, but the
parsing would get more complicated. But the method above means you can
have filenames as long as you want.- Nascondi testo citato

- Mostra testo citato -

Sorry but I didn't get what you mean; When I use the deallocate
command don't I lose all informations pointed by inline? If I
understood right the deallocate command serves to free memory, so if
I
write :

DEALLOCATE(inline);

I will free the memory block used to store the contents of infile;
how
can I find the same contents in a string whose lenght is not
constrained?

Another question: is there a command to know the lenght of a line?
Because I could do so:

READFILE (infile, inline);
int := LENGHT (inline);  -- int already defined as an integer

than i could continue with an IF clause. Unfortunately LENGHT is not
the right keyword.

Thanks again- Nascondi testo citato

- Mostra testo citato -

Ok found the right command:

int := inline'Length;


Bye!

 

[Tricky]

On 30 Apr, 08:45, Dek <daniele.deq...@gmail.com> wrote:

On 28 Apr, 15:28, Tricky <Trickyh...@gmail.com> wrote:



On 28 Apr, 14:01, Dek <daniele.deq...@gmail.com> wrote:

On 25 Apr, 02:21, "KJ" <kkjenni...@sbcglobal.net> wrote:

I think I can't do anything better, because I have to simulate how an
FPGA would work on data coming from a detector, that are already
stored in many .txt files.

One could ask how did those files get created in the first place.  Unless
they were generated from an actual detector, then they were artificially
generated in the first place.  Rather than artificially generating data into
text files and then figuring out how to read them into a testbench it is
much more productive to model the detector in the VHDL testbench and totally
bypass file I/O (which is not really one of VHDL's strengths).

But I'll assume though that you have to work with file I/O.

Now the problem is that such files are thousands and it takes a lot of
time to change manually their name in vhdl code. One idea is to use
Generics, name all data files in a "name.do" file and use "do name.do"
command. Even in this case, however, I have to name files manually one
by one.

Not really.  The name.do file can be easily created with a simple directory
listing command
(Windows command line "dir /b >name.do").  That's pretty easy to do.

Do you know if there is a way to read all files in a folder
without nameing them?

I don't.

The same problem, unfortunately, is for writing, since for each in-
file I have to write one out-file.

Once you've read in a line from 'name.do' you've got a unique input file
name.  I would construct a similarly unique output file name by modifying
the input file name in some fashion (say by appending ".out" to the input
file name).

Kevin Jennings

Ok, I'll definitively thank this group in my thesis! Your idea seems
to work, but there is still a little problem:

the name are of different length! If i do like this:
-----------------------------------------------
Architecture...
Begin
process
    VARIABLE filename : String (23 downto 1);
-----------------------------------------------
it works until it find a filename of lenght different from 23.

I tried to do something like this:
VARIABLE filename : String;
or
VARIABLE filename : String (natural range<>
but I always get an error message.
Have any suggestion?

Thanks

Dek

I assume you are reading the string from a line? well, a line is
actually a pointer to a string.

So, assuming you just have 1 filename per line, you can do something
like:

readline(namefile, inline);

FILE_OPEN(f, inline.all, READ_MODE);
DEALLOCATE(inline);         --drops the pointer

You could do the same if its not just 1 file name per line, but the
parsing would get more complicated. But the method above means you can
have filenames as long as you want.- Nascondi testo citato

- Mostra testo citato -

Sorry but I didn't get what you mean; When I use the deallocate
command don't I lose all informations pointed by inline? If I
understood right the deallocate command serves to free memory, so if
I
write :

DEALLOCATE(inline);

I will free the memory block used to store the contents of infile;
how
can I find the same contents in a string whose lenght is not
constrained?

the READLINE function just copies the next line from the file into
"inline". if you call DEALLOCATE(inline) you are just removing the
pointer to the copy of the line, the file itself is unnaffected and
the next call to readline will correctly read off the next line from
the file.

the previous example still stands. I was only using DEALLOCATE because
I wasnt actually reading anything from the line, I was dereferencing
the pointer with the inline.all call. if you dont deallocate it
without reading all the data off it, the next readline call will just
append the next line onto the end of whatever is left (and in my
example, the whole line would be left)

so the following example is still good, assuming you dont have
anything else on the line other than the filename:

readline(namefile, inline);

FILE_OPEN(f, inline.all, READ_MODE);
DEALLOCATE(inline); --drops the pointer

the good thing about this method is you dont need to declare a string
to read the data off "inline" and restrict it's length, you can just
use the line itself, as the "line" type is just a pointer to a string.

 

[Dek]

On 1 Mag, 17:58, Tricky <Trickyh...@gmail.com> wrote:

On 30 Apr, 08:45, Dek <daniele.deq...@gmail.com> wrote:





On 28 Apr, 15:28, Tricky <Trickyh...@gmail.com> wrote:

On 28 Apr, 14:01, Dek <daniele.deq...@gmail.com> wrote:

On 25 Apr, 02:21, "KJ" <kkjenni...@sbcglobal.net> wrote:

I think I can't do anything better, because I have to simulate how an
FPGA would work on data coming from a detector, that are already
stored in many .txt files.

One could ask how did those files get created in the first place.  Unless
they were generated from an actual detector, then they were artificially
generated in the first place.  Rather than artificially generating data into
text files and then figuring out how to read them into a testbench it is
much more productive to model the detector in the VHDL testbench and totally
bypass file I/O (which is not really one of VHDL's strengths).

But I'll assume though that you have to work with file I/O.

Now the problem is that such files are thousands and it takes a lot of
time to change manually their name in vhdl code. One idea is to use
Generics, name all data files in a "name.do" file and use "do name.do"
command. Even in this case, however, I have to name files manually one
by one.

Not really.  The name.do file can be easily created with a simple directory
listing command
(Windows command line "dir /b >name.do").  That's pretty easy to do.

Do you know if there is a way to read all files in a folder
without nameing them?

I don't.

The same problem, unfortunately, is for writing, since for each in-
file I have to write one out-file.

Once you've read in a line from 'name.do' you've got a unique input file
name.  I would construct a similarly unique output file name by modifying
the input file name in some fashion (say by appending ".out" to the input
file name).

Kevin Jennings

Ok, I'll definitively thank this group in my thesis! Your idea seems
to work, but there is still a little problem:

the name are of different length! If i do like this:
-----------------------------------------------
Architecture...
Begin
process
    VARIABLE filename : String (23 downto 1);
-----------------------------------------------
it works until it find a filename of lenght different from 23.

I tried to do something like this:
VARIABLE filename : String;
or
VARIABLE filename : String (natural range<>
but I always get an error message.
Have any suggestion?

Thanks

Dek

I assume you are reading the string from a line? well, a line is
actually a pointer to a string.

So, assuming you just have 1 filename per line, you can do something
like:

readline(namefile, inline);

FILE_OPEN(f, inline.all, READ_MODE);
DEALLOCATE(inline);         --drops the pointer

You could do the same if its not just 1 file name per line, but the
parsing would get more complicated. But the method above means you can
have filenames as long as you want.- Nascondi testo citato

- Mostra testo citato -

Sorry but I didn't get what you mean; When I use the deallocate
command don't I lose all informations pointed by inline? If I
understood right the deallocate command serves to free memory, so if
I
write :

DEALLOCATE(inline);

I will free the memory block used to store the contents of infile;
how
can I find the same contents in a string whose lenght is not
constrained?

the READLINE function just copies the next line from the file into
"inline". if you call DEALLOCATE(inline) you are just removing the
pointer to the copy of the line, the file itself is unnaffected and
the next call to readline will correctly read off the next line from
the file.

the previous example still stands. I was only using DEALLOCATE because
I wasnt actually reading anything from the line, I was dereferencing
the pointer with the inline.all call. if you dont deallocate it
without reading all the data off it, the next readline call will just
append the next line onto the end of whatever is left (and in my
example, the whole line would be left)

so the following example is still good, assuming you dont have
anything else on the line other than the filename:

readline(namefile, inline);

FILE_OPEN(f, inline.all, READ_MODE);
DEALLOCATE(inline);         --drops the pointer

the good thing about this method is you dont need to declare a string
to read the data off "inline" and restrict it's length, you can just
use the line itself, as the "line" type is just a pointer to a string.- Nascondi testo citato

- Mostra testo citato -

Ok, I think I should explane better what I have to do; my purpose is
to write something like this:

----------------------------------------------------------------------------------------------------------------

READLINE ( filein, buf1); --filein: file where names
are stored; buf1 e buf2 defined as a line;
READ (buf1, filename); --filename define as a
string
WRITE ( buf2, string'("My command 1"));
Write (buf2, filename);
WRITE ( buf2, string'("My command 2"));
WRITELINE (fileout, buf2);

----------------------------------------------------------------------------------------------------------------

Now, I tried to write something like this:

------

readline ( namefile, L);
FILE_OPEN(namefile, L.all, READ_MODE);
DEALLOCATE(L); --drops the pointer
write (buf, L);
writeline (outfile, buf);

--------

but it doesn't work; It would be really nice to don't be forced
declaring string lenght, but I didn't understood yet how to use
properly the deallocate command.

Thanks

Bye

 

[Mike Treseler]

Dek wrote:

but it doesn't work; It would be really nice to don't be forced
declaring string length, but I didn't understood yet how to use
properly the deallocate command.

Consider using the REPORT command for text, and get on
with the testbench.

TextIO has already stolen two weeks of your time.

-- Mike Treseler

 

[JimLewis]

Dek,
Here is something I have used. Make sure that FileName length (20
here)
is big enough to allow you to get the file name. This assumes that
there is no white space at the end of the line. Note though I used
this in a toy program. I only read files for testbenches when I have
a big data set to read in, like a video image or something of that
sort.

use std.textio.all;

TestProc : process
File TestFile : Text ;
variable FileInLine : Line ;
variable FileName : string (1 to 20 ) ;
variable NameLength : natural ;
begin
Write( OUTPUT, "File Name to Read: " & LF);
Read ( INPUT, FileName, NameLength) ;
if (FileName(NameLength) = LF) then
NameLength := NameLength - 1 ;
end if ;
file_open(TestFile, FileName(1 to NameLength), READ_MODE);


Best,
Jim
SynthWorks VHDL Training

 

[JimLewis]

This one handles spaces on the same line as the name, but is much more
tedious

Main : Process

begin
write(WriteBuf, String'("Enter File Name to Read: ")) ;
writeline(OUTPUT, WriteBuf) ;
Readline (INPUT, ReadBuf) ;
i := 1 ;
loop
Read(ReadBuf, InputString(i), Valid) ;
exit when not Valid ;
i := i + 1 ;
end loop ;
if i = 1 then wait; end if ; -- add error handling here
file_open(TestFile, InputString(1 to i-1), READ_MODE) ;


Cheers,
Jim
SynthWorks VHDL Training

 

[JimLewis]

This needs a small modification for your code:

This one handles spaces on the same line as the name, but is much more
tedious

Main : Process

begin
  write(WriteBuf, String'("Enter File Name to Read: ")) ;
  writeline(OUTPUT, WriteBuf) ;
  Readline (INPUT, ReadBuf) ;
  i := 1 ;
  loop
    Read(ReadBuf, InputString(i), Valid) ;

    exit when not Valid or InputString(i) = ' ' or InputString(i) HT ;

    i := i + 1 ;
  end loop ;
  if i = 1 then wait; end if ;   -- add error handling here
  file_open(TestFile, InputString(1 to i-1), READ_MODE) ;

Cheers,

Jim
SynthWorks VHDL Training

 

[Dek]

On 5 Mag, 17:55, JimLewis <j...@synthworks.com> wrote:

This needs a small modification for your code:

This one handles spaces on the same line as the name, but is much more
tedious

Main : Process

begin
  write(WriteBuf, String'("Enter File Name to Read: ")) ;
  writeline(OUTPUT, WriteBuf) ;
  Readline (INPUT, ReadBuf) ;
  i := 1 ;
  loop
    Read(ReadBuf, InputString(i), Valid) ;

      exit when not Valid or InputString(i) = ' ' or InputString(i) > HT ;

    i := i + 1 ;
  end loop ;
  if i = 1 then wait; end if ;   -- add error handling here
  file_open(TestFile, InputString(1 to i-1), READ_MODE) ;

Cheers,
Jim
SynthWorks VHDL Training

Thanks all, it seems a good idea, but finally I used Tcl, it's quite
simple

Bye

Dek

 

[Mike Treseler]

Dek wrote:

Thanks all, it seems a good idea, but finally I used Tcl, it's quite
simple

Glad you saw the light.
tcl is much better at text than vhdl,
as is python, bash script, emacs-lisp, perl, ...

-- Mike Treseler

 

[Dek]

On 7 Mag, 18:42, Mike Treseler <mtrese...@gmail.com> wrote:

Dek wrote:
Thanks all, it seems a good idea, but finally I used Tcl, it's quite
simple

Glad you saw the light.
tcl is much better at text than vhdl,
as is python, bash script, emacs-lisp, perl, ...

           -- Mike Treseler

Hemm... actually I used Tcl just as a macro to be used with modelsim
(as HT-Lab suggested); in my VHDL TextIO is still present, but since I
use the files name as generics, they don't have to be constrained
anymore.

Maybe, as you say, I did better if I used just Tcl or Python or so on,
but I want to take confidence with VHDL for further applications, and
I had data from an actual detector already stored in .txt files.
Anyway I think it's nice to know how TextIO works because, even if
it's not very powerful, it gives you the chance to understeand how an
hardware model would work on data already stored; and I don't think
this is a so rare application.

 

[Mike Treseler]

Dek wrote:
Thanks all, it seems a good idea, but finally I used Tcl, it's quite
simple

Dek wrote:

Hemm... actually I used Tcl just as a macro to be used with modelsim
(as HT-Lab suggested); in my VHDL TextIO is still present, but since I
use the files name as generics, they don't have to be constrained
anymore.

Sorry that I misinterpreted your posting.
Congratulations for conquering textio.

Maybe, as you say, I did better if I used just Tcl or Python or so on,
but I want to take confidence with VHDL for further applications, and
I had data from an actual detector already stored in .txt files.

I prefer to convert existing text files to vhdl packages
using a scripting language, since I am using one anyway
to run modelsim. This isn't better, just different.

-- Mike Treseler