home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / APPS / lout2.lzh / LOUT2 / z26.c < prev    next >
Text File  |  1994-01-23  |  11KB  |  244 lines
  1. /*@z26.c:Echo Service:BeginString()@******************************************/
  2. /*                                                                           */
  3. /*  LOUT: A HIGH-LEVEL LANGUAGE FOR DOCUMENT FORMATTING (VERSION 2.05)       */
  4. /*  COPYRIGHT (C) 1993 Jeffrey H. Kingston                                   */
  5. /*                                                                           */
  6. /*  Jeffrey H. Kingston (jeff@cs.su.oz.au)                                   */
  7. /*  Basser Department of Computer Science                                    */
  8. /*  The University of Sydney 2006                                            */
  9. /*  AUSTRALIA                                                                */
  10. /*                                                                           */
  11. /*  This program is free software; you can redistribute it and/or modify     */
  12. /*  it under the terms of the GNU General Public License as published by     */
  13. /*  the Free Software Foundation; either version 1, or (at your option)      */
  14. /*  any later version.                                                       */
  15. /*                                                                           */
  16. /*  This program is distributed in the hope that it will be useful,          */
  17. /*  but WITHOUT ANY WARRANTY; without even the implied warranty of           */
  18. /*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            */
  19. /*  GNU General Public License for more details.                             */
  20. /*                                                                           */
  21. /*  You should have received a copy of the GNU General Public License        */
  22. /*  along with this program; if not, write to the Free Software              */
  23. /*  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                */
  24. /*                                                                           */
  25. /*  FILE:         z26.c                                                      */
  26. /*  MODULE:       Echo Service                                               */
  27. /*  EXTERNS:      BeginString(), AppendString(), EndString(),                */
  28. /*                EchoLength(), Image()                                      */
  29. /*                                                                           */
  30. /*****************************************************************************/
  31. #include "externs"
  32.  
  33. #if DEBUG_ON
  34. #define    MULTI      7            /* max no of simultaneous calls      */
  35.  
  36. static    FULL_CHAR buff[MULTI][MAX_LINE];/* buffers for strings       */
  37. static    int    curr = 1;        /* current buffer in use             */
  38. static    int    bp;            /* next free space in buff[curr]     */
  39. static    BOOLEAN    instring = FALSE;    /* TRUE while making a string        */
  40.  
  41.  
  42. /*****************************************************************************/
  43. /*                                                                           */
  44. /*  BeginString()                                                            */
  45. /*                                                                           */
  46. /*  Locate a clear buffer into which debug output may be accumulated.        */
  47. /*                                                                           */
  48. /*****************************************************************************/
  49.  
  50. BeginString()
  51. { if( instring ) Error(INTERN, no_fpos, "BeginString: currently in string!");
  52.   instring = TRUE;  curr = (curr + 1) % MULTI;
  53.   assert( 0 <= curr && curr < MULTI, "BeginString: curr!" );
  54.   StringCopy(buff[curr], "");  bp = 0;
  55. }
  56.  
  57.  
  58. /*@::AppendString(), EndString(), EchoLength()@*******************************/
  59. /*                                                                           */
  60. /*  AppendString(str, p1, p2, p3, p4, p5, p6)                                */
  61. /*                                                                           */
  62. /*  Sprintf str to the current buffer, if space is available there.          */
  63. /*                                                                           */
  64. /*****************************************************************************/
  65.  
  66. /*VARARGS1*/
  67. AppendString(str, p1, p2, p3, p4, p5, p6)
  68. FULL_CHAR *str;  int p1, p2, p3, p4, p5, p6;
  69. { int len;
  70.   if( !instring ) Error(INTERN, no_fpos, "AppendString: no current string!");
  71.   assert( 0 <= curr && curr < MULTI, "BeginString: curr!" );
  72.   if( bp == MAX_LINE ) return;        /* no space, do nothing */
  73.  
  74.   len = StringLength(str);
  75.   if( len + bp >= MAX_LINE )
  76.   { StringCopy( &buff[curr][MAX_LINE/2], AsciiToFull(" ... <too long>") );
  77.     bp = MAX_LINE;
  78.   }
  79.   else
  80.   { sprintf( (char *) &buff[curr][bp], str, p1, p2, p3, p4, p5, p6 );
  81.     while( buff[curr][bp] != '\0' )  bp++;
  82.     if( bp >= MAX_LINE )  Error(INTERN, no_fpos, "AppendString abort");
  83.   }
  84. } /* end AppendString */
  85.  
  86.  
  87. /*****************************************************************************/
  88. /*                                                                           */
  89. /*  FULL_CHAR *EndString()                                                   */
  90. /*                                                                           */
  91. /*  Return the string constructed by previous AppendString operations.       */
  92. /*                                                                           */
  93. /*****************************************************************************/
  94.  
  95. FULL_CHAR *EndString()
  96. { if( !instring ) Error(INTERN, no_fpos, "EndString: no current string!");
  97.   assert( 0 <= curr && curr < MULTI, "BeginString: curr!" );
  98.   instring = FALSE;
  99.   return buff[curr];
  100. } /* end Endstring */
  101. #endif
  102.  
  103.  
  104. /*****************************************************************************/
  105. /*                                                                           */
  106. /*  FULL_CHAR *EchoLength(len)                                               */
  107. /*                                                                           */
  108. /*  Echo a length.                                                           */
  109. /*                                                                           */
  110. /*****************************************************************************/
  111.  
  112. FULL_CHAR *EchoLength(len)
  113. int len;
  114. { static FULL_CHAR buff[6][20];
  115.   static int i = 0;
  116.   i = (i + 1) % 6;
  117.   sprintf( (char *) buff[i], "%.3fc", (float) len/CM);
  118.   return buff[i];
  119. } /* end EchoLength */
  120.  
  121.  
  122. /*@::Image()@*****************************************************************/
  123. /*                                                                           */
  124. /*  FULL_CHAR *Image(c)                                                      */
  125. /*                                                                           */
  126. /*  Returns the string value of type c.                                      */
  127. /*                                                                           */
  128. /*****************************************************************************/
  129.  
  130. FULL_CHAR *Image(c)
  131. unsigned int c;
  132. { static FULL_CHAR b[20];
  133.   switch(c)
  134.   {
  135.  
  136.     case LINK:        return  AsciiToFull("link");
  137.  
  138.     case SPLIT:        return  AsciiToFull("split");
  139.     case HEAD:        return  AsciiToFull("head");
  140.     case PAR:        return  AsciiToFull("par");
  141.     case WORD:        return  AsciiToFull("word");
  142.     case QWORD:        return  AsciiToFull("qword");
  143.     case GAP_OBJ:    return  AsciiToFull("gap_obj");
  144.     case ROW_THR:    return  AsciiToFull("row_thr");
  145.     case COL_THR:    return  AsciiToFull("col_thr");
  146.     case CLOSURE:    return  AsciiToFull("closure");
  147.     case NULL_CLOS:    return  KW_NULL;
  148.     case CROSS:        return  KW_CROSS;
  149.     case ONE_COL:    return  KW_ONE_COL;
  150.     case ONE_ROW:    return  KW_ONE_ROW;
  151.     case WIDE:        return  KW_WIDE;
  152.     case HIGH:        return  KW_HIGH;
  153.     case HSCALE:    return  KW_HSCALE;
  154.     case VSCALE:    return  KW_VSCALE;
  155.     case HCONTRACT:    return  KW_HCONTRACT;
  156.     case VCONTRACT:    return  KW_VCONTRACT;
  157.     case HEXPAND:    return  KW_HEXPAND;
  158.     case VEXPAND:    return  KW_VEXPAND;
  159.     case PADJUST:    return  KW_PADJUST;
  160.     case HADJUST:    return  KW_HADJUST;
  161.     case VADJUST:    return  KW_VADJUST;
  162.     case ROTATE:    return  KW_ROTATE;
  163.     case SCALE:        return  KW_SCALE;
  164.     case CASE:        return  KW_CASE;
  165.     case YIELD:        return  KW_YIELD;
  166.     case XCHAR:        return  KW_XCHAR;
  167.     case FONT:        return  KW_FONT;
  168.     case SPACE:        return  KW_SPACE;
  169.     case BREAK:        return  KW_BREAK;
  170.     case NEXT:        return  KW_NEXT;
  171.     case ENV:        return  KW_ENV;
  172.     case CLOS:        return  KW_CLOS;
  173.     case LVIS:        return  KW_LVIS;
  174.     case OPEN:        return  KW_OPEN;
  175.     case TAGGED:    return  KW_TAGGED;
  176.     case INCGRAPHIC:    return  KW_INCGRAPHIC;
  177.     case SINCGRAPHIC:    return  KW_SINCGRAPHIC;
  178.     case GRAPHIC:    return  KW_GRAPHIC;
  179.     case ACAT:        return  AsciiToFull("acat");
  180.     case HCAT:        return  AsciiToFull("hcat");
  181.     case VCAT:        return  AsciiToFull("vcat");
  182.  
  183.     case TSPACE:    return  AsciiToFull("tspace");
  184.     case TJUXTA:    return  AsciiToFull("tjuxta");
  185.     case LBR:        return  AsciiToFull("lbr");
  186.     case RBR:        return  AsciiToFull("rbr");
  187.     case BEGIN:        return  KW_BEGIN;
  188.     case END:        return  KW_END;
  189.     case USE:        return  KW_USE;
  190.     case GSTUB_NONE:    return  AsciiToFull("gstub_none");
  191.     case GSTUB_INT:    return  AsciiToFull("gstub_int");
  192.     case GSTUB_EXT:    return  AsciiToFull("gstub_ext");
  193.     case INCLUDE:    return  KW_INCLUDE;
  194.     case SYS_INCLUDE:    return  KW_SYSINCLUDE;
  195.     case PREPEND:    return  KW_PREPEND;
  196.     case SYS_PREPEND:    return  KW_SYSPREPEND;
  197.     case DATABASE:    return  KW_DATABASE;
  198.     case SYS_DATABASE:    return  KW_SYSDATABASE;
  199.     case START:         return  AsciiToFull("start");
  200.  
  201.     case DEAD:        return  AsciiToFull("dead");
  202.     case UNATTACHED:    return  AsciiToFull("unattached");
  203.     case RECEPTIVE:    return  AsciiToFull("receptive");
  204.     case RECEIVING:    return  AsciiToFull("receiving");
  205.     case RECURSIVE:    return  AsciiToFull("recursive");
  206.     case PRECEDES:    return  AsciiToFull("precedes");
  207.     case FOLLOWS:    return  AsciiToFull("follows");
  208.     case CROSS_FOLL:    return  AsciiToFull("cross_foll");
  209.     case GALL_FOLL:    return  AsciiToFull("gall_foll");
  210.     case CROSS_TARG:    return  AsciiToFull("cross_targ");
  211.     case GALL_TARG:    return  AsciiToFull("gall_targ");
  212.     case GALL_PREC:    return  AsciiToFull("gall_prec");
  213.     case CROSS_PREC:    return  AsciiToFull("cross_prec");
  214.     case EXPAND_IND:    return  AsciiToFull("expand_ind");
  215.     case THREAD:    return  AsciiToFull("thread");
  216.     case CROSS_SYM:    return  AsciiToFull("cross_sym");
  217.     case CR_ROOT:    return  AsciiToFull("cr_root");
  218.     case MACRO:        return  KW_MACRO;
  219.     case LOCAL:        return  AsciiToFull("local");
  220.     case LPAR:        return  AsciiToFull("lpar");
  221.     case NPAR:        return  AsciiToFull("npar");
  222.     case RPAR:        return  AsciiToFull("rpar");
  223.     case CR_LIST:    return  AsciiToFull("cr_list");
  224.     case EXT_GALL:    return  AsciiToFull("ext_gall");
  225.     case DISPOSED:    return  AsciiToFull("disposed");
  226.  
  227.     case BACK:        return  AsciiToFull("back");
  228.     case ON:        return  AsciiToFull("on");
  229.     case FWD:        return  AsciiToFull("fwd");
  230.  
  231.     case PROMOTE:    return  AsciiToFull("promote");
  232.     case CLOSE:        return  AsciiToFull("close");
  233.     case BLOCK:        return  AsciiToFull("block");
  234.     case CLEAR:        return  AsciiToFull("clear");
  235.  
  236.     case GAP_ABS:    return  AsciiToFull("abs");
  237.     case GAP_INC:    return  AsciiToFull("inc");
  238.     case GAP_DEC:    return  AsciiToFull("dec");
  239.  
  240.     default:        sprintf( (char *) b, "??(%d)", c);
  241.             return b;
  242.   } /* end switch */
  243. } /* end Image */
  244.