1%-*-mode:latex-*- 2%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 3% 4% Copyright (C) 1996-2005 Jason Evans <jasone@canonware.com>. 5% All rights reserved. 6% 7% Redistribution and use in source and binary forms, with or without 8% modification, are permitted provided that the following conditions 9% are met: 10% 1. Redistributions of source code must retain the above copyright 11% notice(s), this list of conditions and the following disclaimer 12% unmodified other than the allowable addition of one or more 13% copyright notices. 14% 2. Redistributions in binary form must reproduce the above copyright 15% notice(s), this list of conditions and the following disclaimer in 16% the documentation and/or other materials provided with the 17% distribution. 18% 19% THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY 20% EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21% IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22% PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE 23% LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24% CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25% SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 26% BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 27% WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 28% OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, 29% EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30% 31%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 32% 33% Version: Onyx 5.1.2 34% 35% outputsdict reference portion of Onyx Manual. 36% 37%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 38 39\subsection{outputsdict} 40\label{sec:outputsdict} 41\index{outputsdict@\onyxop{}{outputsdict}{}} 42 43The outputsdict dictionary is primarily used to support 44\htmlref{\onyxop{}{outputs}{}}{systemdict:outputs}, but its contents may be of 45use to an application that wishes to extend or modify formatted printing. 46 47There is an entry in outputsdict for each Onyx type. Each entry renders objects 48that correspond to its name using optional flags stored in a dictionary. The 49following flags are supported for all types: 50\begin{description} 51\item[{\tt \$n}: ] 52 Maximum length, in bytes. Default: disabled. 53\item[{\tt \$w}: ] 54 Minimum length, in bytes. Default: disabled. 55\item[{\tt \$j}: ] 56 Justification. Legal values: 57 \begin{description} 58 \item[{\tt \$l}: ] 59 Left. 60 \item[{\tt \$c}: ] 61 Center. 62 \item[{\tt \$r}: ] 63 Right (default). 64 \end{description} 65\item[{\tt \$p}: ] 66 Padding character. Default: {\tt ` '}. 67\item[{\tt \$r}: ] 68 Syntactic rendering recursion depth. Default: 1. 69\end{description} 70 71The following additional flags are supported for integers: 72\begin{description} 73\item[{\tt \$b}: ] 74 Base, from 2 to 36. Default: 10. 75\item[{\tt \$s}: ] 76 Sign. Legal values: 77 \begin{description} 78 \item[{\tt \$-}: ] 79 Only print sign if output is negative (default). 80 \item[{\tt \$+}: ] 81 Always print sign. 82 \end{description} 83\end{description} 84 85The following additional flags are supported for reals: 86\begin{description} 87\item[{\tt \$d}: ] 88 Digits of precision past decimal point. Default: 6. 89\item[{\tt \$e}: ] 90 Exponential notation, if true. Default: false. 91\end{description} 92 93\begin{longtable}{\optableformat{4.10}} 94\caption{outputsdict summary} 95\\ 96\hline 97\optableent 98 {Input(s)} 99 {Op/Proc/Var} 100 {Output(s)} 101 {Description} 102\hline \hline 103%begin{latexonly} 104\endfirsthead 105\caption[]{\emph{continued}} \\ 106\hline 107\optableent 108 {Input(s)} 109 {Op/Proc/Var} 110 {Output(s)} 111 {Description} 112\hline \hline \endhead 113\multicolumn{2}{r}{\emph{Continued on next page...}} \endfoot 114\hline \endlastfoot 115%end{latexonly} 116\optableent 117 {array flags} 118 {{\bf \htmlref{arraytype}{outputsdict:arraytype}}} 119 {string} 120 {Create formatted string from array.} 121\hline 122\optableent 123 {boolean flags} 124 {{\bf \htmlref{booleantype}{outputsdict:booleantype}}} 125 {string} 126 {Create formatted string from boolean.} 127\hline 128\optableent 129 {class flags} 130 {{\bf \htmlref{classtype}{outputsdict:classtype}}} 131 {string} 132 {Create formatted string from class.} 133\hline 134\optableent 135 {condition flags} 136 {{\bf \htmlref{conditiontype}{outputsdict:conditiontype}}} 137 {string} 138 {Create formatted string from condition.} 139\hline 140\optableent 141 {dict flags} 142 {{\bf \htmlref{dicttype}{outputsdict:dicttype}}} 143 {string} 144 {Create formatted string from dict.} 145\hline 146\optableent 147 {file flags} 148 {{\bf \htmlref{filetype}{outputsdict:filetype}}} 149 {string} 150 {Create formatted string from file.} 151\hline 152\optableent 153 {fino flags} 154 {{\bf \htmlref{finotype}{outputsdict:finotype}}} 155 {string} 156 {Create formatted string from fino.} 157\hline 158\optableent 159 {handle flags} 160 {{\bf \htmlref{handletype}{outputsdict:handletype}}} 161 {string} 162 {Create formatted string from handle.} 163\hline 164\optableent 165 {instance flags} 166 {{\bf \htmlref{instancetype}{outputsdict:instancetype}}} 167 {string} 168 {Create formatted string from instance.} 169\hline 170\optableent 171 {integer flags} 172 {{\bf \htmlref{integertype}{outputsdict:integertype}}} 173 {string} 174 {Create formatted string from integer.} 175\hline 176\optableent 177 {mark flags} 178 {{\bf \htmlref{marktype}{outputsdict:marktype}}} 179 {string} 180 {Create formatted string from mark.} 181\hline 182\optableent 183 {mutex flags} 184 {{\bf \htmlref{mutextype}{outputsdict:mutextype}}} 185 {string} 186 {Create formatted string from mutex.} 187\hline 188\optableent 189 {name flags} 190 {{\bf \htmlref{nametype}{outputsdict:nametype}}} 191 {string} 192 {Create formatted string from name.} 193\hline 194\optableent 195 {null flags} 196 {{\bf \htmlref{nulltype}{outputsdict:nulltype}}} 197 {string} 198 {Create formatted string from null.} 199\hline 200\optableent 201 {operator flags} 202 {{\bf \htmlref{operatortype}{outputsdict:operatortype}}} 203 {string} 204 {Create formatted string from operator.} 205\hline 206\optableent 207 {pmark flags} 208 {{\bf \htmlref{pmarktype}{outputsdict:pmarktype}}} 209 {string} 210 {Create formatted string from pmark.} 211\hline 212\optableent 213 {real flags} 214 {{\bf \htmlref{realtype}{outputsdict:realtype}}} 215 {string} 216 {Create formatted string from real.} 217\hline 218\optableent 219 {regex flags} 220 {{\bf \htmlref{regextype}{outputsdict:regextype}}} 221 {string} 222 {Create formatted string from regex.} 223\hline 224\optableent 225 {regsub flags} 226 {{\bf \htmlref{regsubtype}{outputsdict:regsubtype}}} 227 {string} 228 {Create formatted string from regsub.} 229\hline 230\optableent 231 {stack flags} 232 {{\bf \htmlref{stacktype}{outputsdict:stacktype}}} 233 {string} 234 {Create formatted string from stack.} 235\hline 236\optableent 237 {string flags} 238 {{\bf \htmlref{stringtype}{outputsdict:stringtype}}} 239 {string} 240 {Create formatted string from string.} 241\hline 242\optableent 243 {thread flags} 244 {{\bf \htmlref{threadtype}{outputsdict:threadtype}}} 245 {string} 246 {Create formatted string from thread.} 247\end{longtable} 248 249\begin{description} 250\label{outputsdict:arraytype} 251\index{arraytype@\onyxop{}{arraytype}{}} 252\item[{\onyxop{array flags}{arraytype}{string}}: ] 253 \begin{description}\item[] 254 \item[Input(s): ] 255 \begin{description}\item[] 256 \item[array: ] 257 An array object. 258 \item[flags: ] 259 Formatting flags. 260 \end{description} 261 \item[Output(s): ] 262 \begin{description}\item[] 263 \item[string: ] 264 Formatted string representation of \oparg{array}. 265 \end{description} 266 \item[Error(s): ] 267 \begin{description}\item[] 268 \item[\htmlref{stackunderflow}{stackunderflow}.] 269 \item[\htmlref{typecheck}{typecheck}.] 270 \end{description} 271 \item[Description: ] 272 Create a formatted string representation of \oparg{array}. 273 \item[Example(s): ]\begin{verbatim} 274 275onyx:0> outputsdict begin 276onyx:0> [1 [2 3] 4] 277onyx:1> dup <$w 9 $p `_' $r 0> arraytype print `\n' print flush 278__-array- 279onyx:1> dup <$w 9 $p `_' $r 1> arraytype print `\n' print flush 280[1 -array- 4] 281onyx:1> 282 \end{verbatim} 283 \end{description} 284\label{outputsdict:booleantype} 285\index{booleantype@\onyxop{}{booleantype}{}} 286\item[{\onyxop{boolean flags}{booleantype}{string}}: ] 287 \begin{description}\item[] 288 \item[Input(s): ] 289 \begin{description}\item[] 290 \item[boolean: ] 291 A boolean object. 292 \item[flags: ] 293 Formatting flags. 294 \end{description} 295 \item[Output(s): ] 296 \begin{description}\item[] 297 \item[string: ] 298 Formatted string representation of \oparg{boolean}. 299 \end{description} 300 \item[Error(s): ] 301 \begin{description}\item[] 302 \item[\htmlref{stackunderflow}{stackunderflow}.] 303 \item[\htmlref{typecheck}{typecheck}.] 304 \end{description} 305 \item[Description: ] 306 Create a formatted string representation of \oparg{boolean}. 307 \item[Example(s): ]\begin{verbatim} 308 309onyx:0> outputsdict begin 310onyx:0> false 311onyx:1> dup <$n 3> booleantype print `\n' print flush 312fal 313onyx:1> dup <$n 7> booleantype print `\n' print flush 314false 315onyx:1> 316 \end{verbatim} 317 \end{description} 318\label{outputsdict:classtype} 319\index{classtype@\onyxop{}{classtype}{}} 320\item[{\onyxop{class flags}{classtype}{string}}: ] 321 \begin{description}\item[] 322 \item[Input(s): ] 323 \begin{description}\item[] 324 \item[class: ] 325 A class object. 326 \item[flags: ] 327 Formatting flags. 328 \end{description} 329 \item[Output(s): ] 330 \begin{description}\item[] 331 \item[string: ] 332 Formatted string representation of \oparg{class}. 333 \end{description} 334 \item[Error(s): ] 335 \begin{description}\item[] 336 \item[\htmlref{stackunderflow}{stackunderflow}.] 337 \item[\htmlref{typecheck}{typecheck}.] 338 \end{description} 339 \item[Description: ] 340 Create a formatted string representation of \oparg{class}. 341 \item[Example(s): ]\begin{verbatim} 342 343onyx:0> outputsdict begin 344onyx:0> vclass 345onyx:1> <$w 30 $p `.' $j $c> classtype print `\n' print flush 346...........-class-............ 347onyx:0> 348 \end{verbatim} 349 \end{description} 350\label{outputsdict:conditiontype} 351\index{conditiontype@\onyxop{}{conditiontype}{}} 352\item[{\onyxop{condition flags}{conditiontype}{string}}: ] 353 \begin{description}\item[] 354 \item[Input(s): ] 355 \begin{description}\item[] 356 \item[condition: ] 357 A condition object. 358 \item[flags: ] 359 Formatting flags. 360 \end{description} 361 \item[Output(s): ] 362 \begin{description}\item[] 363 \item[string: ] 364 Formatted string representation of \oparg{condition}. 365 \end{description} 366 \item[Error(s): ] 367 \begin{description}\item[] 368 \item[\htmlref{stackunderflow}{stackunderflow}.] 369 \item[\htmlref{typecheck}{typecheck}.] 370 \end{description} 371 \item[Description: ] 372 Create a formatted string representation of \oparg{condition}. 373 \item[Example(s): ]\begin{verbatim} 374 375onyx:0> outputsdict begin 376onyx:0> condition 377onyx:1> <$w 15 $p `_' $j $c> booleantype print `\n' print flush 378__-condition-__ 379onyx:0> 380 \end{verbatim} 381 \end{description} 382\label{outputsdict:dicttype} 383\index{dicttype@\onyxop{}{dicttype}{}} 384\item[{\onyxop{dict flags}{dicttype}{string}}: ] 385 \begin{description}\item[] 386 \item[Input(s): ] 387 \begin{description}\item[] 388 \item[dict: ] 389 A dict object. 390 \item[flags: ] 391 Formatting flags. 392 \end{description} 393 \item[Output(s): ] 394 \begin{description}\item[] 395 \item[string: ] 396 Formatted string representation of \oparg{dict}. 397 \end{description} 398 \item[Error(s): ] 399 \begin{description}\item[] 400 \item[\htmlref{stackunderflow}{stackunderflow}.] 401 \item[\htmlref{typecheck}{typecheck}.] 402 \end{description} 403 \item[Description: ] 404 Create a formatted string representation of \oparg{dict}. 405 \item[Example(s): ]\begin{verbatim} 406 407onyx:0> outputsdict begin 408onyx:0> <$foo `foo'> <$w 30 $p `.' $j $r> dicttype print `\n' print flush 409..................<$foo `foo'> 410onyx:0> 411 \end{verbatim} 412 \end{description} 413\label{outputsdict:filetype} 414\index{filetype@\onyxop{}{filetype}{}} 415\item[{\onyxop{file flags}{filetype}{string}}: ] 416 \begin{description}\item[] 417 \item[Input(s): ] 418 \begin{description}\item[] 419 \item[file: ] 420 A file object. 421 \item[flags: ] 422 Formatting flags. 423 \end{description} 424 \item[Output(s): ] 425 \begin{description}\item[] 426 \item[string: ] 427 Formatted string representation of \oparg{file}. 428 \end{description} 429 \item[Error(s): ] 430 \begin{description}\item[] 431 \item[\htmlref{stackunderflow}{stackunderflow}.] 432 \item[\htmlref{typecheck}{typecheck}.] 433 \end{description} 434 \item[Description: ] 435 Create a formatted string representation of \oparg{file}. 436 \item[Example(s): ]\begin{verbatim} 437 438onyx:0> outputsdict begin 439onyx:0> stdin 440onyx:1> <$w 30 $p `.' $j $c> filetype print `\n' print flush 441............-file-............ 442onyx:0> 443 \end{verbatim} 444 \end{description} 445\label{outputsdict:finotype} 446\index{finotype@\onyxop{}{finotype}{}} 447\item[{\onyxop{fino flags}{finotype}{string}}: ] 448 \begin{description}\item[] 449 \item[Input(s): ] 450 \begin{description}\item[] 451 \item[fino: ] 452 A fino object. 453 \item[flags: ] 454 Formatting flags. 455 \end{description} 456 \item[Output(s): ] 457 \begin{description}\item[] 458 \item[string: ] 459 Formatted string representation of \oparg{fino}. 460 \end{description} 461 \item[Error(s): ] 462 \begin{description}\item[] 463 \item[\htmlref{stackunderflow}{stackunderflow}.] 464 \item[\htmlref{typecheck}{typecheck}.] 465 \end{description} 466 \item[Description: ] 467 Create a formatted string representation of \oparg{fino}. 468 \item[Example(s): ]\begin{verbatim} 469 470onyx:0> outputsdict begin 471onyx:0> ( 472onyx:1> <$w 30 $p `.' $j $c> finotype print `\n' print flush 473............-fino-............ 474onyx:0> 475 \end{verbatim} 476 \end{description} 477\label{outputsdict:handletype} 478\index{handletype@\onyxop{}{handletype}{}} 479\item[{\onyxop{handle flags}{handletype}{string}}: ] 480 \begin{description}\item[] 481 \item[Input(s): ] 482 \begin{description}\item[] 483 \item[handle: ] 484 A handle object. 485 \item[flags: ] 486 Formatting flags. 487 \end{description} 488 \item[Output(s): ] 489 \begin{description}\item[] 490 \item[string: ] 491 Formatted string representation of \oparg{handle}. 492 \end{description} 493 \item[Error(s): ] 494 \begin{description}\item[] 495 \item[\htmlref{stackunderflow}{stackunderflow}.] 496 \item[\htmlref{typecheck}{typecheck}.] 497 \end{description} 498 \item[Description: ] 499 Create a formatted string representation of \oparg{handle}. 500 \item[Example(s): ] 501 The following example is a bit contrived, since there is no way 502 to create a handle object with a stock onyx interpreter. 503 Therefore, imagine that an operator named taggedhandle exists 504 that creates a handle with a tag that is the name ``tagged''. 505 \begin{verbatim} 506 507onyx:0> outputsdict begin 508onyx:0> taggedhandle 509onyx:1> <$w 30 $p `.' $j $l handletype print `\n' print flush 510=tagged=...................... 511onyx:0> 512 \end{verbatim} 513 \end{description} 514\label{outputsdict:instancetype} 515\index{instancetype@\onyxop{}{instancetype}{}} 516\item[{\onyxop{instance flags}{instancetype}{string}}: ] 517 \begin{description}\item[] 518 \item[Input(s): ] 519 \begin{description}\item[] 520 \item[instance: ] 521 An instance object. 522 \item[flags: ] 523 Formatting flags. 524 \end{description} 525 \item[Output(s): ] 526 \begin{description}\item[] 527 \item[string: ] 528 Formatted string representation of \oparg{instance}. 529 \end{description} 530 \item[Error(s): ] 531 \begin{description}\item[] 532 \item[\htmlref{stackunderflow}{stackunderflow}.] 533 \item[\htmlref{typecheck}{typecheck}.] 534 \end{description} 535 \item[Description: ] 536 Create a formatted string representation of \oparg{instance}. 537 \item[Example(s): ]\begin{verbatim} 538 539onyx:0> outputsdict begin 540onyx:0> vinstance 541onyx:1> <$w 30 $p `.' $j $c> instancetype print `\n' print flush 542..........-instance-.......... 543onyx:0> 544 \end{verbatim} 545 \end{description} 546\label{outputsdict:integertype} 547\index{integertype@\onyxop{}{integertype}{}} 548\item[{\onyxop{integer flags}{integertype}{string}}: ] 549 \begin{description}\item[] 550 \item[Input(s): ] 551 \begin{description}\item[] 552 \item[integer: ] 553 An integer object. 554 \item[flags: ] 555 Formatting flags. 556 \end{description} 557 \item[Output(s): ] 558 \begin{description}\item[] 559 \item[string: ] 560 Formatted string representation of \oparg{integer}. 561 \end{description} 562 \item[Error(s): ] 563 \begin{description}\item[] 564 \item[\htmlref{stackunderflow}{stackunderflow}.] 565 \item[\htmlref{typecheck}{typecheck}.] 566 \end{description} 567 \item[Description: ] 568 Create a formatted string representation of \oparg{integer}. 569 \item[Example(s): ]\begin{verbatim} 570 571onyx:0> outputsdict begin 572onyx:0> 42 <$w 6 $p `_' $j $c $s $-> integertype print `\n' print flush 573__42__ 574onyx:0> 42 <$w 6 $p `_' $j $c $s $+> integertype print `\n' print flush 575_+42__ 576onyx:0> `0x' print 42 <$w 6 $p `0' $b 16> integertype print `\n' print flush 5770x00002a 578onyx:0> 579 \end{verbatim} 580 \end{description} 581\label{outputsdict:marktype} 582\index{marktype@\onyxop{}{marktype}{}} 583\item[{\onyxop{mark flags}{marktype}{string}}: ] 584 \begin{description}\item[] 585 \item[Input(s): ] 586 \begin{description}\item[] 587 \item[mark: ] 588 A mark object. 589 \item[flags: ] 590 Formatting flags. 591 \end{description} 592 \item[Output(s): ] 593 \begin{description}\item[] 594 \item[string: ] 595 Formatted string representation of \oparg{mark}. 596 \end{description} 597 \item[Error(s): ] 598 \begin{description}\item[] 599 \item[\htmlref{stackunderflow}{stackunderflow}.] 600 \item[\htmlref{typecheck}{typecheck}.] 601 \end{description} 602 \item[Description: ] 603 Create a formatted string representation of \oparg{mark}. 604 \item[Example(s): ]\begin{verbatim} 605 606onyx:0> outputsdict begin 607onyx:0> mark 608onyx:1> <$w 30 $p `.' $j $c> marktype print `\n' print flush 609............-mark-............ 610onyx:0> 611 \end{verbatim} 612 \end{description} 613\label{outputsdict:mutextype} 614\index{mutextype@\onyxop{}{mutextype}{}} 615\item[{\onyxop{mutex flags}{mutextype}{string}}: ] 616 \begin{description}\item[] 617 \item[Input(s): ] 618 \begin{description}\item[] 619 \item[mutex: ] 620 A mutex object. 621 \item[flags: ] 622 Formatting flags. 623 \end{description} 624 \item[Output(s): ] 625 \begin{description}\item[] 626 \item[string: ] 627 Formatted string representation of \oparg{mutex}. 628 \end{description} 629 \item[Error(s): ] 630 \begin{description}\item[] 631 \item[\htmlref{stackunderflow}{stackunderflow}.] 632 \item[\htmlref{typecheck}{typecheck}.] 633 \end{description} 634 \item[Description: ] 635 Create a formatted string representation of \oparg{mutex}. 636 \item[Example(s): ]\begin{verbatim} 637 638onyx:0> outputsdict begin 639onyx:0> mutex 640onyx:1> <$w 30 $p `.' $j $c> mutextype print `\n' print flush 641...........-mutex-............ 642onyx:0> 643 \end{verbatim} 644 \end{description} 645\label{outputsdict:nametype} 646\index{nametype@\onyxop{}{nametype}{}} 647\item[{\onyxop{name flags}{nametype}{string}}: ] 648 \begin{description}\item[] 649 \item[Input(s): ] 650 \begin{description}\item[] 651 \item[name: ] 652 A name object. 653 \item[flags: ] 654 Formatting flags. 655 \end{description} 656 \item[Output(s): ] 657 \begin{description}\item[] 658 \item[string: ] 659 Formatted string representation of \oparg{name}. 660 \end{description} 661 \item[Error(s): ] 662 \begin{description}\item[] 663 \item[\htmlref{stackunderflow}{stackunderflow}.] 664 \item[\htmlref{typecheck}{typecheck}.] 665 \end{description} 666 \item[Description: ] 667 Create a formatted string representation of \oparg{name}. 668 \item[Example(s): ]\begin{verbatim} 669 670onyx:0> outputsdict begin 671onyx:0> $foo 672onyx:1> <$w 30 $p `.' $j $c> nametype print `\n' print flush 673.............$foo............. 674onyx:0> 675 \end{verbatim} 676 \end{description} 677\label{outputsdict:nulltype} 678\index{nulltype@\onyxop{}{nulltype}{}} 679\item[{\onyxop{null flags}{nulltype}{string}}: ] 680 \begin{description}\item[] 681 \item[Input(s): ] 682 \begin{description}\item[] 683 \item[null: ] 684 A null object. 685 \item[flags: ] 686 Formatting flags. 687 \end{description} 688 \item[Output(s): ] 689 \begin{description}\item[] 690 \item[string: ] 691 Formatted string representation of \oparg{null}. 692 \end{description} 693 \item[Error(s): ] 694 \begin{description}\item[] 695 \item[\htmlref{stackunderflow}{stackunderflow}.] 696 \item[\htmlref{typecheck}{typecheck}.] 697 \end{description} 698 \item[Description: ] 699 Create a formatted string representation of \oparg{null}. 700 \item[Example(s): ]\begin{verbatim} 701 702onyx:0> outputsdict begin 703onyx:0> null 704onyx:1> <$w 30 $p `.' $j $c> nulltype print `\n' print flush 705.............null............. 706onyx:0> 707 \end{verbatim} 708 \end{description} 709\label{outputsdict:operatortype} 710\index{operatortype@\onyxop{}{operatortype}{}} 711\item[{\onyxop{operator flags}{operatortype}{string}}: ] 712 \begin{description}\item[] 713 \item[Input(s): ] 714 \begin{description}\item[] 715 \item[operator: ] 716 An operator object. 717 \item[flags: ] 718 Formatting flags. 719 \end{description} 720 \item[Output(s): ] 721 \begin{description}\item[] 722 \item[string: ] 723 Formatted string representation of \oparg{operator}. 724 \end{description} 725 \item[Error(s): ] 726 \begin{description}\item[] 727 \item[\htmlref{stackunderflow}{stackunderflow}.] 728 \item[\htmlref{typecheck}{typecheck}.] 729 \end{description} 730 \item[Description: ] 731 Create a formatted string representation of \oparg{operator}. 732 \item[Example(s): ] 733 The following example shows an operator printed out with two 734 leading and trailing dashes. If the interpreter cannot 735 determine the name associated with an operator, as will be the 736 case for custom operators, the operator will be printed as 737 {\tt -operator-}. 738 \begin{verbatim} 739 740onyx:0> outputsdict begin 741onyx:0> ~realtime 742onyx:1> <$w 30 $p `.' $j $c> operatortype print `\n' print flush 743.........--realtime--......... 744onyx:0> 745 \end{verbatim} 746 \end{description} 747\label{outputsdict:pmarktype} 748\index{pmarktype@\onyxop{}{pmarktype}{}} 749\item[{\onyxop{pmark flags}{pmarktype}{string}}: ] 750 \begin{description}\item[] 751 \item[Input(s): ] 752 \begin{description}\item[] 753 \item[pmark: ] 754 A pmark object. 755 \item[flags: ] 756 Formatting flags. 757 \end{description} 758 \item[Output(s): ] 759 \begin{description}\item[] 760 \item[string: ] 761 Formatted string representation of \oparg{pmark}. 762 \end{description} 763 \item[Error(s): ] 764 \begin{description}\item[] 765 \item[\htmlref{stackunderflow}{stackunderflow}.] 766 \item[\htmlref{typecheck}{typecheck}.] 767 \end{description} 768 \item[Description: ] 769 Create a formatted string representation of \oparg{pmark}. 770 \item[Example(s): ]\begin{verbatim} 771 772onyx:0> outputsdict begin 773onyx:0> { ~x 774Error $undefined 775ostack: (-pmark- $x) 776dstack: (-dict- -dict- -dict- -dict- -dict-) 777cstack: () 778estack/istack trace (0..1): 7790: -file- 7801: --start-- 781onyx:3> pop pop resume 782onyx:1> <$w 30 $p `.' $j $c> pmarktype print `\n' print flush 783...........-pmark-............ 784onyx:0> 785 \end{verbatim} 786 \end{description} 787\label{outputsdict:realtype} 788\index{realtype@\onyxop{}{realtype}{}} 789\item[{\onyxop{real flags}{realtype}{string}}: ] 790 \begin{description}\item[] 791 \item[Input(s): ] 792 \begin{description}\item[] 793 \item[real: ] 794 A real object. 795 \item[flags: ] 796 Formatting flags. 797 \end{description} 798 \item[Output(s): ] 799 \begin{description}\item[] 800 \item[string: ] 801 Formatted string representation of \oparg{real}. 802 \end{description} 803 \item[Error(s): ] 804 \begin{description}\item[] 805 \item[\htmlref{stackunderflow}{stackunderflow}.] 806 \item[\htmlref{typecheck}{typecheck}.] 807 \end{description} 808 \item[Description: ] 809 Create a formatted string representation of \oparg{real}. 810 \item[Example(s): ]\begin{verbatim} 811 812onyx:0> outputsdict begin 813onyx:0> 6.022e23 <$d 4> realtype print `\n' print flush 814602200000000000027262976.0000 815onyx:0> 6.022e23 <$d 4 $e true> realtype print `\n' print flush 8166.0220e+23 817onyx:0> 6.022e23 <$d 0 $e true> realtype print `\n' print flush 8186e+23 819onyx:0> 6.022e23 <$d 4 $w 40 $p `0'> realtype print `\n' print flush 82000000000000602200000000000027262976.0000 821onyx:0> 822 \end{verbatim} 823 \end{description} 824\label{outputsdict:regextype} 825\index{regextype@\onyxop{}{regextype}{}} 826\item[{\onyxop{regex flags}{regextype}{string}}: ] 827 \begin{description}\item[] 828 \item[Input(s): ] 829 \begin{description}\item[] 830 \item[regex: ] 831 A regex object. 832 \item[flags: ] 833 Formatting flags. 834 \end{description} 835 \item[Output(s): ] 836 \begin{description}\item[] 837 \item[string: ] 838 Formatted string representation of \oparg{regex}. 839 \end{description} 840 \item[Error(s): ] 841 \begin{description}\item[] 842 \item[\htmlref{stackunderflow}{stackunderflow}.] 843 \item[\htmlref{typecheck}{typecheck}.] 844 \end{description} 845 \item[Description: ] 846 Create a formatted string representation of \oparg{regex}. 847 \item[Example(s): ]\begin{verbatim} 848 849onyx:0> outputsdict begin 850onyx:0> `' regex 851onyx:1> <$w 30 $p `.' $j $c> regextype print `\n' print flush 852...........-regex-............ 853onyx:0> 854 \end{verbatim} 855 \end{description} 856\label{outputsdict:regsubtype} 857\index{regsubtype@\onyxop{}{regsubtype}{}} 858\item[{\onyxop{regsub flags}{regsubtype}{string}}: ] 859 \begin{description}\item[] 860 \item[Input(s): ] 861 \begin{description}\item[] 862 \item[regsub: ] 863 A regsub object. 864 \item[flags: ] 865 Formatting flags. 866 \end{description} 867 \item[Output(s): ] 868 \begin{description}\item[] 869 \item[string: ] 870 Formatted string representation of \oparg{regsub}. 871 \end{description} 872 \item[Error(s): ] 873 \begin{description}\item[] 874 \item[\htmlref{stackunderflow}{stackunderflow}.] 875 \item[\htmlref{typecheck}{typecheck}.] 876 \end{description} 877 \item[Description: ] 878 Create a formatted string representation of \oparg{regsub}. 879 \item[Example(s): ]\begin{verbatim} 880 881onyx:0> outputsdict begin 882onyx:0> `' `' regsub 883onyx:1> <$w 30 $p `.' $j $c> regsubtype print `\n' print flush 884...........-regsub-........... 885onyx:0> 886 \end{verbatim} 887 \end{description} 888\label{outputsdict:stacktype} 889\index{stacktype@\onyxop{}{stacktype}{}} 890\item[{\onyxop{stack flags}{stacktype}{string}}: ] 891 \begin{description}\item[] 892 \item[Input(s): ] 893 \begin{description}\item[] 894 \item[stack: ] 895 A stack object. 896 \item[flags: ] 897 Formatting flags. 898 \end{description} 899 \item[Output(s): ] 900 \begin{description}\item[] 901 \item[string: ] 902 Formatted string representation of \oparg{stack}. 903 \end{description} 904 \item[Error(s): ] 905 \begin{description}\item[] 906 \item[\htmlref{stackunderflow}{stackunderflow}.] 907 \item[\htmlref{typecheck}{typecheck}.] 908 \end{description} 909 \item[Description: ] 910 Create a formatted string representation of \oparg{stack}. 911 \item[Example(s): ]\begin{verbatim} 912 913onyx:0> outputsdict begin 914onyx:0> (1 (2 3) 4) 915onyx:1> dup <$w 9 $p `_' $r 0> stacktype print `\n' print flush 916__-stack- 917onyx:1> <$w 9 $p `_' $r 1> stacktype print `\n' print flush 918(1 -stack- 4) 919onyx:0> 920 \end{verbatim} 921 \end{description} 922\label{outputsdict:stringtype} 923\index{stringtype@\onyxop{}{stringtype}{}} 924\item[{\onyxop{string flags}{stringtype}{string}}: ] 925 \begin{description}\item[] 926 \item[Input(s): ] 927 \begin{description}\item[] 928 \item[string: ] 929 A string object. 930 \item[flags: ] 931 Formatting flags. 932 \end{description} 933 \item[Output(s): ] 934 \begin{description}\item[] 935 \item[string: ] 936 Formatted string representation of \oparg{string}. 937 \end{description} 938 \item[Error(s): ] 939 \begin{description}\item[] 940 \item[\htmlref{stackunderflow}{stackunderflow}.] 941 \item[\htmlref{typecheck}{typecheck}.] 942 \end{description} 943 \item[Description: ] 944 Create a formatted string representation of \oparg{string}. 945 \item[Example(s): ]\begin{verbatim} 946 947onyx:0> outputsdict begin 948onyx:0> `A string' 949onyx:1> <$w 30 $p `.' $j $c> stringtype print `\n' print flush 950...........A string........... 951onyx:0> 952 \end{verbatim} 953 \end{description} 954\label{outputsdict:threadtype} 955\index{threadtype@\onyxop{}{threadtype}{}} 956\item[{\onyxop{thread flags}{threadtype}{string}}: ] 957 \begin{description}\item[] 958 \item[Input(s): ] 959 \begin{description}\item[] 960 \item[thread: ] 961 A thread object. 962 \item[flags: ] 963 Formatting flags. 964 \end{description} 965 \item[Output(s): ] 966 \begin{description}\item[] 967 \item[string: ] 968 Formatted string representation of \oparg{thread}. 969 \end{description} 970 \item[Error(s): ] 971 \begin{description}\item[] 972 \item[\htmlref{stackunderflow}{stackunderflow}.] 973 \item[\htmlref{typecheck}{typecheck}.] 974 \end{description} 975 \item[Description: ] 976 Create a formatted string representation of \oparg{thread}. 977 \item[Example(s): ]\begin{verbatim} 978 979onyx:0> outputsdict begin 980onyx:0> () {} thread 981onyx:1> <$w 30 $p `.' $j $c> threadtype print `\n' print flush 982...........-thread-........... 983onyx:0> 984 \end{verbatim} 985 \end{description} 986\end{description} 987