1---------------------------------------------------------------------------- 2-- 3-- Copyright (c) 1990, 1991, 1992 by Synopsys, Inc. All rights reserved. 4-- 5-- This source file may be used and distributed without restriction 6-- provided that this copyright statement is not removed from the file 7-- and that any derivative work contains this copyright notice. 8-- 9-- Package name: STD_LOGIC_TEXTIO 10-- 11-- Purpose: This package overloads the standard TEXTIO procedures 12-- READ and WRITE. 13-- 14-- Author: CRC, TS 15-- 16---------------------------------------------------------------------------- 17 18use STD.textio.all; 19library IEEE; 20use IEEE.std_logic_1164.all; 21 22package STD_LOGIC_TEXTIO is 23--synopsys synthesis_off 24 -- Read and Write procedures for STD_ULOGIC and STD_ULOGIC_VECTOR 25 procedure READ(L:inout LINE; VALUE:out STD_ULOGIC); 26 procedure READ(L:inout LINE; VALUE:out STD_ULOGIC; GOOD: out BOOLEAN); 27 procedure READ(L:inout LINE; VALUE:out STD_ULOGIC_VECTOR); 28 procedure READ(L:inout LINE; VALUE:out STD_ULOGIC_VECTOR; GOOD: out BOOLEAN); 29 procedure WRITE(L:inout LINE; VALUE:in STD_ULOGIC; 30 JUSTIFIED:in SIDE := RIGHT; FIELD:in WIDTH := 0); 31 procedure WRITE(L:inout LINE; VALUE:in STD_ULOGIC_VECTOR; 32 JUSTIFIED:in SIDE := RIGHT; FIELD:in WIDTH := 0); 33 34 -- Read and Write procedures for STD_LOGIC_VECTOR 35 procedure READ(L:inout LINE; VALUE:out STD_LOGIC_VECTOR); 36 procedure READ(L:inout LINE; VALUE:out STD_LOGIC_VECTOR; GOOD: out BOOLEAN); 37 procedure WRITE(L:inout LINE; VALUE:in STD_LOGIC_VECTOR; 38 JUSTIFIED:in SIDE := RIGHT; FIELD:in WIDTH := 0); 39 40 -- 41 -- Read and Write procedures for Hex and Octal values. 42 -- The values appear in the file as a series of characters 43 -- between 0-F (Hex), or 0-7 (Octal) respectively. 44 -- 45 46 -- Hex 47 procedure HREAD(L:inout LINE; VALUE:out STD_ULOGIC_VECTOR); 48 procedure HREAD(L:inout LINE; VALUE:out STD_ULOGIC_VECTOR; GOOD: out BOOLEAN); 49 procedure HWRITE(L:inout LINE; VALUE:in STD_ULOGIC_VECTOR; 50 JUSTIFIED:in SIDE := RIGHT; FIELD:in WIDTH := 0); 51 procedure HREAD(L:inout LINE; VALUE:out STD_LOGIC_VECTOR); 52 procedure HREAD(L:inout LINE; VALUE:out STD_LOGIC_VECTOR; GOOD: out BOOLEAN); 53 procedure HWRITE(L:inout LINE; VALUE:in STD_LOGIC_VECTOR; 54 JUSTIFIED:in SIDE := RIGHT; FIELD:in WIDTH := 0); 55 56 -- Octal 57 procedure OREAD(L:inout LINE; VALUE:out STD_ULOGIC_VECTOR); 58 procedure OREAD(L:inout LINE; VALUE:out STD_ULOGIC_VECTOR; GOOD: out BOOLEAN); 59 procedure OWRITE(L:inout LINE; VALUE:in STD_ULOGIC_VECTOR; 60 JUSTIFIED:in SIDE := RIGHT; FIELD:in WIDTH := 0); 61 procedure OREAD(L:inout LINE; VALUE:out STD_LOGIC_VECTOR); 62 procedure OREAD(L:inout LINE; VALUE:out STD_LOGIC_VECTOR; GOOD: out BOOLEAN); 63 procedure OWRITE(L:inout LINE; VALUE:in STD_LOGIC_VECTOR; 64 JUSTIFIED:in SIDE := RIGHT; FIELD:in WIDTH := 0); 65 66 67--synopsys synthesis_on 68end STD_LOGIC_TEXTIO; 69 70package body STD_LOGIC_TEXTIO is 71--synopsys synthesis_off 72 73 -- Type and constant definitions used to map STD_ULOGIC values 74 -- into/from character values. 75 76 type MVL9plus is ('U', 'X', '0', '1', 'Z', 'W', 'L', 'H', '-', ERROR); 77 type char_indexed_by_MVL9 is array (STD_ULOGIC) of character; 78 type MVL9_indexed_by_char is array (character) of STD_ULOGIC; 79 type MVL9plus_indexed_by_char is array (character) of MVL9plus; 80 81 constant MVL9_to_char: char_indexed_by_MVL9 := "UX01ZWLH-"; 82 constant char_to_MVL9: MVL9_indexed_by_char := 83 ('U' => 'U', 'X' => 'X', '0' => '0', '1' => '1', 'Z' => 'Z', 84 'W' => 'W', 'L' => 'L', 'H' => 'H', '-' => '-', others => 'U'); 85 constant char_to_MVL9plus: MVL9plus_indexed_by_char := 86 ('U' => 'U', 'X' => 'X', '0' => '0', '1' => '1', 'Z' => 'Z', 87 'W' => 'W', 'L' => 'L', 'H' => 'H', '-' => '-', others => ERROR); 88 89 90 -- Overloaded procedures. 91 92 procedure READ(L:inout LINE; VALUE:out STD_ULOGIC; GOOD:out BOOLEAN) is 93 variable c: character; 94 begin 95 loop -- skip white space 96 read(l,c); 97 exit when ((c /= ' ') and (c /= CR) and (c /= HT)); 98 end loop; 99 100 if (char_to_MVL9plus(c) = ERROR) then 101 value := 'U'; 102 good := FALSE; 103 else 104 value := char_to_MVL9(c); 105 good := TRUE; 106 end if; 107 end READ; 108 109 procedure READ(L:inout LINE; VALUE:out STD_ULOGIC_VECTOR; GOOD:out BOOLEAN) is 110 variable m: STD_ULOGIC; 111 variable c: character; 112 variable s: string(1 to value'length-1); 113 variable mv: STD_ULOGIC_VECTOR(0 to value'length-1); 114 constant allU: STD_ULOGIC_VECTOR(0 to value'length-1) 115 := (others => 'U'); 116 begin 117 loop -- skip white space 118 read(l,c); 119 exit when ((c /= ' ') and (c /= CR) and (c /= HT)); 120 end loop; 121 122 if (char_to_MVL9plus(c) = ERROR) then 123 value := allU; 124 good := FALSE; 125 return; 126 end if; 127 128 read(l, s); 129 for i in integer range 1 to value'length-1 loop 130 if (char_to_MVL9plus(s(i)) = ERROR) then 131 value := allU; 132 good := FALSE; 133 return; 134 end if; 135 end loop; 136 137 mv(0) := char_to_MVL9(c); 138 for i in integer range 1 to value'length-1 loop 139 mv(i) := char_to_MVL9(s(i)); 140 end loop; 141 value := mv; 142 good := TRUE; 143 end READ; 144 145 procedure READ(L:inout LINE; VALUE:out STD_ULOGIC) is 146 variable c: character; 147 begin 148 loop -- skip white space 149 read(l,c); 150 exit when ((c /= ' ') and (c /= CR) and (c /= HT)); 151 end loop; 152 153 if (char_to_MVL9plus(c) = ERROR) then 154 value := 'U'; 155 assert FALSE report "READ(STD_ULOGIC) Error: Character '" & 156 c & "' read, expected STD_ULOGIC literal."; 157 else 158 value := char_to_MVL9(c); 159 end if; 160 end READ; 161 162 procedure READ(L:inout LINE; VALUE:out STD_ULOGIC_VECTOR) is 163 variable m: STD_ULOGIC; 164 variable c: character; 165 variable s: string(1 to value'length-1); 166 variable mv: STD_ULOGIC_VECTOR(0 to value'length-1); 167 constant allU: STD_ULOGIC_VECTOR(0 to value'length-1) 168 := (others => 'U'); 169 begin 170 loop -- skip white space 171 read(l,c); 172 exit when ((c /= ' ') and (c /= CR) and (c /= HT)); 173 end loop; 174 175 if (char_to_MVL9plus(c) = ERROR) then 176 value := allU; 177 assert FALSE report 178 "READ(STD_ULOGIC_VECTOR) Error: Character '" & 179 c & "' read, expected STD_ULOGIC literal."; 180 return; 181 end if; 182 183 read(l, s); 184 for i in integer range 1 to value'length-1 loop 185 if (char_to_MVL9plus(s(i)) = ERROR) then 186 value := allU; 187 assert FALSE report 188 "READ(STD_ULOGIC_VECTOR) Error: Character '" & 189 s(i) & "' read, expected STD_ULOGIC literal."; 190 return; 191 end if; 192 end loop; 193 194 mv(0) := char_to_MVL9(c); 195 for i in integer range 1 to value'length-1 loop 196 mv(i) := char_to_MVL9(s(i)); 197 end loop; 198 value := mv; 199 end READ; 200 201 procedure WRITE(L:inout LINE; VALUE:in STD_ULOGIC; 202 JUSTIFIED:in SIDE := RIGHT; FIELD:in WIDTH := 0) is 203 begin 204 write(l, MVL9_to_char(value), justified, field); 205 end WRITE; 206 207 208 procedure WRITE(L:inout LINE; VALUE:in STD_ULOGIC_VECTOR; 209 JUSTIFIED:in SIDE := RIGHT; FIELD:in WIDTH := 0) is 210 variable s: string(1 to value'length); 211 variable m: STD_ULOGIC_VECTOR(1 to value'length) := value; 212 begin 213 for i in 1 to value'length loop 214 s(i) := MVL9_to_char(m(i)); 215 end loop; 216 write(l, s, justified, field); 217 end WRITE; 218 219 -- Read and Write procedures for STD_LOGIC_VECTOR 220 procedure READ(L:inout LINE; VALUE:out STD_LOGIC_VECTOR) is 221 variable tmp: STD_ULOGIC_VECTOR(VALUE'length-1 downto 0); 222 begin 223 READ(L, tmp); 224 VALUE := STD_LOGIC_VECTOR(tmp); 225 end READ; 226 227 procedure READ(L:inout LINE; VALUE:out STD_LOGIC_VECTOR; GOOD: out BOOLEAN) is 228 variable tmp: STD_ULOGIC_VECTOR(VALUE'length-1 downto 0); 229 begin 230 READ(L, tmp, GOOD); 231 VALUE := STD_LOGIC_VECTOR(tmp); 232 end READ; 233 234 procedure WRITE(L:inout LINE; VALUE:in STD_LOGIC_VECTOR; 235 JUSTIFIED:in SIDE := RIGHT; FIELD:in WIDTH := 0) is 236 begin 237 WRITE(L, STD_ULOGIC_VECTOR(VALUE), JUSTIFIED, FIELD); 238 end WRITE; 239 240 241 -- 242 -- Hex Read and Write procedures. 243 -- 244 245 -- 246 -- Hex, and Octal Read and Write procedures for BIT_VECTOR 247 -- (these procedures are not exported, they are only used 248 -- by the STD_ULOGIC hex/octal reads and writes below. 249 -- 250 -- 251 252 procedure Char2QuadBits(C: Character; 253 RESULT: out Bit_Vector(3 downto 0); 254 GOOD: out Boolean; 255 ISSUE_ERROR: in Boolean) is 256 begin 257 case c is 258 when '0' => result := x"0"; good := TRUE; 259 when '1' => result := x"1"; good := TRUE; 260 when '2' => result := x"2"; good := TRUE; 261 when '3' => result := x"3"; good := TRUE; 262 when '4' => result := x"4"; good := TRUE; 263 when '5' => result := x"5"; good := TRUE; 264 when '6' => result := x"6"; good := TRUE; 265 when '7' => result := x"7"; good := TRUE; 266 when '8' => result := x"8"; good := TRUE; 267 when '9' => result := x"9"; good := TRUE; 268 when 'A' => result := x"A"; good := TRUE; 269 when 'B' => result := x"B"; good := TRUE; 270 when 'C' => result := x"C"; good := TRUE; 271 when 'D' => result := x"D"; good := TRUE; 272 when 'E' => result := x"E"; good := TRUE; 273 when 'F' => result := x"F"; good := TRUE; 274 275 when 'a' => result := x"A"; good := TRUE; 276 when 'b' => result := x"B"; good := TRUE; 277 when 'c' => result := x"C"; good := TRUE; 278 when 'd' => result := x"D"; good := TRUE; 279 when 'e' => result := x"E"; good := TRUE; 280 when 'f' => result := x"F"; good := TRUE; 281 when others => 282 if ISSUE_ERROR then 283 assert FALSE report 284 "HREAD Error: Read a '" & c & 285 "', expected a Hex character (0-F)."; 286 end if; 287 good := FALSE; 288 end case; 289 end; 290 291 procedure HREAD(L:inout LINE; VALUE:out BIT_VECTOR) is 292 variable ok: boolean; 293 variable c: character; 294 constant ne: integer := value'length/4; 295 variable bv: bit_vector(0 to value'length-1); 296 variable s: string(1 to ne-1); 297 begin 298 if value'length mod 4 /= 0 then 299 assert FALSE report 300 "HREAD Error: Trying to read vector " & 301 "with an odd (non multiple of 4) length"; 302 return; 303 end if; 304 305 loop -- skip white space 306 read(l,c); 307 exit when ((c /= ' ') and (c /= CR) and (c /= HT)); 308 end loop; 309 310 Char2QuadBits(c, bv(0 to 3), ok, TRUE); 311 if not ok then 312 return; 313 end if; 314 315 read(L, s, ok); 316 if not ok then 317 assert FALSE 318 report "HREAD Error: Failed to read the STRING"; 319 return; 320 end if; 321 322 for i in 1 to ne-1 loop 323 Char2QuadBits(s(i), bv(4*i to 4*i+3), ok, TRUE); 324 if not ok then 325 return; 326 end if; 327 end loop; 328 value := bv; 329 end HREAD; 330 331 procedure HREAD(L:inout LINE; VALUE:out BIT_VECTOR;GOOD: out BOOLEAN) is 332 variable ok: boolean; 333 variable c: character; 334 constant ne: integer := value'length/4; 335 variable bv: bit_vector(0 to value'length-1); 336 variable s: string(1 to ne-1); 337 begin 338 if value'length mod 4 /= 0 then 339 good := FALSE; 340 return; 341 end if; 342 343 loop -- skip white space 344 read(l,c); 345 exit when ((c /= ' ') and (c /= CR) and (c /= HT)); 346 end loop; 347 348 Char2QuadBits(c, bv(0 to 3), ok, FALSE); 349 if not ok then 350 good := FALSE; 351 return; 352 end if; 353 354 read(L, s, ok); 355 if not ok then 356 good := FALSE; 357 return; 358 end if; 359 360 for i in 1 to ne-1 loop 361 Char2QuadBits(s(i), bv(4*i to 4*i+3), ok, FALSE); 362 if not ok then 363 good := FALSE; 364 return; 365 end if; 366 end loop; 367 good := TRUE; 368 value := bv; 369 end HREAD; 370 371 372 procedure HWRITE(L:inout LINE; VALUE:in BIT_VECTOR; 373 JUSTIFIED:in SIDE := RIGHT; FIELD:in WIDTH := 0) is 374 variable quad: bit_vector(0 to 3); 375 constant ne: integer := value'length/4; 376 variable bv: bit_vector(0 to value'length-1) := value; 377 variable s: string(1 to ne); 378 begin 379 if value'length mod 4 /= 0 then 380 assert FALSE report 381 "HWRITE Error: Trying to read vector " & 382 "with an odd (non multiple of 4) length"; 383 return; 384 end if; 385 386 for i in 0 to ne-1 loop 387 quad := bv(4*i to 4*i+3); 388 case quad is 389 when x"0" => s(i+1) := '0'; 390 when x"1" => s(i+1) := '1'; 391 when x"2" => s(i+1) := '2'; 392 when x"3" => s(i+1) := '3'; 393 when x"4" => s(i+1) := '4'; 394 when x"5" => s(i+1) := '5'; 395 when x"6" => s(i+1) := '6'; 396 when x"7" => s(i+1) := '7'; 397 when x"8" => s(i+1) := '8'; 398 when x"9" => s(i+1) := '9'; 399 when x"A" => s(i+1) := 'A'; 400 when x"B" => s(i+1) := 'B'; 401 when x"C" => s(i+1) := 'C'; 402 when x"D" => s(i+1) := 'D'; 403 when x"E" => s(i+1) := 'E'; 404 when x"F" => s(i+1) := 'F'; 405 end case; 406 end loop; 407 write(L, s, JUSTIFIED, FIELD); 408 end HWRITE; 409 410 procedure Char2TriBits(C: Character; 411 RESULT: out bit_vector(2 downto 0); 412 GOOD: out Boolean; 413 ISSUE_ERROR: in Boolean) is 414 begin 415 case c is 416 when '0' => result := o"0"; good := TRUE; 417 when '1' => result := o"1"; good := TRUE; 418 when '2' => result := o"2"; good := TRUE; 419 when '3' => result := o"3"; good := TRUE; 420 when '4' => result := o"4"; good := TRUE; 421 when '5' => result := o"5"; good := TRUE; 422 when '6' => result := o"6"; good := TRUE; 423 when '7' => result := o"7"; good := TRUE; 424 when others => 425 if ISSUE_ERROR then 426 assert FALSE report 427 "OREAD Error: Read a '" & c & 428 "', expected an Octal character (0-7)."; 429 end if; 430 good := FALSE; 431 end case; 432 end; 433 434 procedure OREAD(L:inout LINE; VALUE:out BIT_VECTOR) is 435 variable c: character; 436 variable ok: boolean; 437 constant ne: integer := value'length/3; 438 variable bv: bit_vector(0 to value'length-1); 439 variable s: string(1 to ne-1); 440 begin 441 if value'length mod 3 /= 0 then 442 assert FALSE report 443 "OREAD Error: Trying to read vector " & 444 "with an odd (non multiple of 3) length"; 445 return; 446 end if; 447 448 loop -- skip white space 449 read(l,c); 450 exit when ((c /= ' ') and (c /= CR) and (c /= HT)); 451 end loop; 452 453 Char2TriBits(c, bv(0 to 2), ok, TRUE); 454 if not ok then 455 return; 456 end if; 457 458 read(L, s, ok); 459 if not ok then 460 assert FALSE 461 report "OREAD Error: Failed to read the STRING"; 462 return; 463 end if; 464 465 for i in 1 to ne-1 loop 466 Char2TriBits(s(i), bv(3*i to 3*i+2), ok, TRUE); 467 if not ok then 468 return; 469 end if; 470 end loop; 471 value := bv; 472 end OREAD; 473 474 procedure OREAD(L:inout LINE; VALUE:out BIT_VECTOR;GOOD: out BOOLEAN) is 475 variable ok: boolean; 476 variable c: character; 477 constant ne: integer := value'length/3; 478 variable bv: bit_vector(0 to value'length-1); 479 variable s: string(1 to ne-1); 480 begin 481 if value'length mod 3 /= 0 then 482 good := FALSE; 483 return; 484 end if; 485 486 loop -- skip white space 487 read(l,c); 488 exit when ((c /= ' ') and (c /= CR) and (c /= HT)); 489 end loop; 490 491 Char2TriBits(c, bv(0 to 2), ok, FALSE); 492 if not ok then 493 good := FALSE; 494 return; 495 end if; 496 497 read(L, s, ok); 498 if not ok then 499 good := FALSE; 500 return; 501 end if; 502 503 for i in 1 to ne-1 loop 504 Char2TriBits(s(i), bv(3*i to 3*i+2), ok, FALSE); 505 if not ok then 506 good := FALSE; 507 return; 508 end if; 509 end loop; 510 good := TRUE; 511 value := bv; 512 end OREAD; 513 514 515 procedure OWRITE(L:inout LINE; VALUE:in BIT_VECTOR; 516 JUSTIFIED:in SIDE := RIGHT; FIELD:in WIDTH := 0) is 517 variable tri: bit_vector(0 to 2); 518 constant ne: integer := value'length/3; 519 variable bv: bit_vector(0 to value'length-1) := value; 520 variable s: string(1 to ne); 521 begin 522 if value'length mod 3 /= 0 then 523 assert FALSE report 524 "OWRITE Error: Trying to read vector " & 525 "with an odd (non multiple of 3) length"; 526 return; 527 end if; 528 529 for i in 0 to ne-1 loop 530 tri := bv(3*i to 3*i+2); 531 case tri is 532 when o"0" => s(i+1) := '0'; 533 when o"1" => s(i+1) := '1'; 534 when o"2" => s(i+1) := '2'; 535 when o"3" => s(i+1) := '3'; 536 when o"4" => s(i+1) := '4'; 537 when o"5" => s(i+1) := '5'; 538 when o"6" => s(i+1) := '6'; 539 when o"7" => s(i+1) := '7'; 540 end case; 541 end loop; 542 write(L, s, JUSTIFIED, FIELD); 543 end OWRITE; 544 545 -- Hex Read and Write procedures for STD_LOGIC_VECTOR 546 procedure HREAD(L:inout LINE; VALUE:out STD_ULOGIC_VECTOR;GOOD:out BOOLEAN) is 547 variable tmp: bit_vector(VALUE'length-1 downto 0); 548 begin 549 HREAD(L, tmp, GOOD); 550 VALUE := To_X01(tmp); 551 end HREAD; 552 553 procedure HREAD(L:inout LINE; VALUE:out STD_ULOGIC_VECTOR) is 554 variable tmp: bit_vector(VALUE'length-1 downto 0); 555 begin 556 HREAD(L, tmp); 557 VALUE := To_X01(tmp); 558 end HREAD; 559 560 procedure HWRITE(L:inout LINE; VALUE:in STD_ULOGIC_VECTOR; 561 JUSTIFIED:in SIDE := RIGHT; FIELD:in WIDTH := 0) is 562 begin 563 HWRITE(L, To_bitvector(VALUE),JUSTIFIED, FIELD); 564 end HWRITE; 565 566 -- Hex Read and Write procedures for STD_LOGIC_VECTOR 567 568 procedure HREAD(L:inout LINE; VALUE:out STD_LOGIC_VECTOR) is 569 variable tmp: STD_ULOGIC_VECTOR(VALUE'length-1 downto 0); 570 begin 571 HREAD(L, tmp); 572 VALUE := STD_LOGIC_VECTOR(tmp); 573 end HREAD; 574 575 procedure HREAD(L:inout LINE; VALUE:out STD_LOGIC_VECTOR; GOOD: out BOOLEAN) is 576 variable tmp: STD_ULOGIC_VECTOR(VALUE'length-1 downto 0); 577 begin 578 HREAD(L, tmp, GOOD); 579 VALUE := STD_LOGIC_VECTOR(tmp); 580 end HREAD; 581 582 procedure HWRITE(L:inout LINE; VALUE:in STD_LOGIC_VECTOR; 583 JUSTIFIED:in SIDE := RIGHT; FIELD:in WIDTH := 0) is 584 begin 585 HWRITE(L, To_bitvector(VALUE), JUSTIFIED, FIELD); 586 end HWRITE; 587 588 589 -- Octal Read and Write procedures for STD_ULOGIC_VECTOR 590 procedure OREAD(L:inout LINE; VALUE:out STD_ULOGIC_VECTOR;GOOD:out BOOLEAN) is 591 variable tmp: bit_vector(VALUE'length-1 downto 0); 592 begin 593 OREAD(L, tmp, GOOD); 594 VALUE := To_X01(tmp); 595 end OREAD; 596 597 procedure OREAD(L:inout LINE; VALUE:out STD_ULOGIC_VECTOR) is 598 variable tmp: bit_vector(VALUE'length-1 downto 0); 599 begin 600 OREAD(L, tmp); 601 VALUE := To_X01(tmp); 602 end OREAD; 603 604 procedure OWRITE(L:inout LINE; VALUE:in STD_ULOGIC_VECTOR; 605 JUSTIFIED:in SIDE := RIGHT; FIELD:in WIDTH := 0) is 606 begin 607 OWRITE(L, To_bitvector(VALUE),JUSTIFIED, FIELD); 608 end OWRITE; 609 610 -- Octal Read and Write procedures for STD_LOGIC_VECTOR 611 612 procedure OREAD(L:inout LINE; VALUE:out STD_LOGIC_VECTOR) is 613 variable tmp: STD_ULOGIC_VECTOR(VALUE'length-1 downto 0); 614 begin 615 OREAD(L, tmp); 616 VALUE := STD_LOGIC_VECTOR(tmp); 617 end OREAD; 618 619 procedure OREAD(L:inout LINE; VALUE:out STD_LOGIC_VECTOR; GOOD: out BOOLEAN) is 620 variable tmp: STD_ULOGIC_VECTOR(VALUE'length-1 downto 0); 621 begin 622 OREAD(L, tmp, GOOD); 623 VALUE := STD_LOGIC_VECTOR(tmp); 624 end OREAD; 625 626 procedure OWRITE(L:inout LINE; VALUE:in STD_LOGIC_VECTOR; 627 JUSTIFIED:in SIDE := RIGHT; FIELD:in WIDTH := 0) is 628 begin 629 OWRITE(L, STD_ULOGIC_VECTOR(VALUE), JUSTIFIED, FIELD); 630 end OWRITE; 631 632 633--synopsys synthesis_on 634end STD_LOGIC_TEXTIO; 635