summaryrefslogtreecommitdiff
path: root/web/funnelAC/sources/lister.c
blob: 1f86e9ef4a01f533380c9a4ad1b4acb96d858c95 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
/*##############################################################################

FUNNNELWEB COPYRIGHT
====================
FunnelWeb is a literate-programming macro preprocessor.

Copyright (C) 1992 Ross N. Williams.

   Ross N. Williams
   ross@spam.adelaide.edu.au
   16 Lerwick Avenue, Hazelwood Park 5066, Australia.

This program is free software; you can redistribute it and/or modify
it under the terms of Version 2 of the GNU General Public License as
published by the Free Software Foundation.

This program is distributed WITHOUT ANY WARRANTY; without even the implied
warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See Version 2 of the GNU General Public License for more details.

You should have received a copy of Version 2 of the GNU General Public
License along with this program. If not, you can FTP the license from
prep.ai.mit.edu/pub/gnu/COPYING-2 or write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

Section 2a of the license requires that all changes to this file be
recorded prominently in this file. Please record all changes here.

Programmers:
   RNW  Ross N. Williams  ross@spam.adelaide.edu.au

Changes:
   07-May-1992  RNW  Program prepared for release under GNU GPL V2.

##############################################################################*/


/******************************************************************************/
/*                                    LISTER.C                                */
/******************************************************************************/

#include "style.h"

#include "as.h"
#include "data.h"
#include "list.h"
#include "lister.h"
#include "machin.h"
#include "misc.h"
#include "table.h"
#include "writfile.h"

/******************************************************************************/

#define LISTWIDTH     80  /* Nominal width of listing file. Can be wider.     */
#define INDENTQ        3  /* Indentation quantum for include files.           */
#define MESSMAXCH    200  /* Maximum number of characters in a message.       */
#define CTXINF       100  /* Special value that signals infinite context.     */
#define MAXLINES   10000  /* Maximum number of lines in input file.           */

/******************************************************************************/

/* The following #defines and typedef define an enumerated type for message   */
/* kinds. There are four kinds of message, and we need a type for storing     */
/* this information. mess_k_t stands for message_kind_type.                   */
/* We use #defines instead of enums as enums are not portable enough.         */
#define MESS_MES 1
#define MESS_WAR 2
#define MESS_ERR 3
#define MESS_SEV 4
typedef ubyte mess_k_t;

/* We wish to store messages in a table with message positions as keys.       */
/* However, the table package will not tolerate duplicate keys. To solve this */
/* problem, we create a new type 'unqpos_t' (unique position type) which has  */
/* not only a position but a serial number as well.                           */
typedef struct
  {
   ps_t  up_pos;
   ulong up_serial;
  } unqpos_t;

/* The following structure stores a single message. As we are storing COPIES  */
/* of the messages, we impose a maximum limit (MESSMAXCH) to their length.    */
typedef struct
  {
   mess_k_t ms_kind;
   char     ms_text[MESSMAXCH+1];
  } mess_t;

/******************************************************************************/

LOCVAR p_tb_t p_msgtab;           /* The message table storing diagnostics.   */
LOCVAR ulong  serial_next;        /* Serial number for numbering messages.    */

/******************************************************************************/

LOCAL int cmpuqpos P_((unqpos_t *,unqpos_t *));
LOCAL int cmpuqpos(p1,p2)
/* Compare two unique positions for the table package and returns [-1,0,1].   */
unqpos_t *p1;
unqpos_t *p2;
{
 long  diff;
 ubyte i;

 for (i=1; i<=3; i++)
   {
    switch (i)
      {
       case 1: diff= p1->up_pos.ps_line   - p2->up_pos.ps_line;   break;
       case 2: diff= p1->up_pos.ps_column - p2->up_pos.ps_column; break;
       case 3: diff= p1->up_serial        - p2->up_serial;  break;
       default: as_bomb("cmpuqpos: Case defaulted.");
      }
    if (diff<0)
       return -1;
    else
       if (diff>0)
          return 1;
   }
 return 0;
}

/******************************************************************************/

/* Converts a value of message kind type into a representative string. */
/* This routine unused at present.
LOCAL char *mess_let P_((mess_k_t));
LOCAL char *mess_let (mess_k)
mess_k_t mess_k;
{
 switch (mess_k)
   {
    case MESS_MES : return "M";
    case MESS_WAR : return "W";
    case MESS_ERR : return "E";
    case MESS_SEV : return "S";
    default: as_bomb("mess_let: Case defaulted.");
   }
 as_bomb("mess_let: Switch dropped out.");
 return "Failure";
}
*/

/******************************************************************************/

#define DUPMAX 200

LOCAL char *dup P_((int,uword));
LOCAL char *dup(ch,count)
/* Returns a pointer to a STAVAR string containing 'count' copies of 'ch'.    */
/* Count must be in the range [0,DUPMAX]. The pointer returned always points  */
/* to the same address which is a 'STAVAR' inside this function.              */
int   ch;
uword count;
{
 STAVAR char buffer[DUPMAX+1];

 as_cold(count<DUPMAX,"lister.dup: count>=DUPMAX");
 /* The IF in the following is just in case 'memset' is brain damaged. */
 if (count>0) memset(&buffer[0],ch,(size_t) count);
 buffer[count]=EOS;
 return &buffer[0];
}

/******************************************************************************/

LOCAL void mess_wri P_((p_wf_t,mess_t *,uword,uword));
LOCAL void mess_wri(p_wf,p_mess,indent,column)
/* Writes message p_mess to file p_wf indented by INDENTQ*indent+column.      */
p_wf_t p_wf;
mess_t *p_mess;
uword  indent;
uword  column;
{
 switch (p_mess->ms_kind)
   {
    case MESS_MES : wf_wr(p_wf,"            "); break;
    case MESS_WAR : wf_wr(p_wf,"     Warning"); break;
    case MESS_ERR : wf_wr(p_wf,"       Error"); break;
    case MESS_SEV : wf_wr(p_wf,"      Severe"); break;
    default: as_bomb("mess_let: Case defaulted.");
   }
 wf_wr(p_wf,"|.");
 wf_wr(p_wf,dup('.',indent*INDENTQ));
 wf_wr(p_wf,dup('.',column-1));
 wf_wr(p_wf,"^");
 wf_wr(p_wf,&p_mess->ms_text[0]);
 wf_wr(p_wf,"\n");
}

/******************************************************************************/

LOCAL void line_wri P_((p_wf_t,ln_t *));
LOCAL void line_wri(p_wf,p_line)
/* Writes the given line to the given output stream. */
p_wf_t  p_wf;
ln_t   *p_line;
{
 char buffer[100];

 /* The last line of the line list is the EOF marker line and to indicate     */
 /* that it is not really part of the input file, we omit it's line number.   */
 if (p_line->ln_global==ls_len(line_list))
                 /*" 12345 12345| "*/
    sprintf(buffer,"            | ");
 else
    sprintf(buffer," %5lu %5lu| ",
                   (unsigned long) p_line->ln_global,
                   (unsigned long) p_line->ln_local);
 wf_wr(p_wf,buffer);
 wf_blk(p_wf,p_line->ln_body.sc_first,(size_t)
     (p_line->ln_body.sc_last-p_line->ln_body.sc_first+1));
}

/******************************************************************************/

LOCAL void add_mess P_((ps_t *,mess_k_t,char *));
LOCAL void add_mess(p_pos,messkind,p_string)
/* Creates a message record and places the message information in the         */
/* argument into the record. Inserts the record into the message table.       */
ps_t      *p_pos;
mess_k_t   messkind;
char      *p_string;
{
 mess_t   tempmess;
 unqpos_t unqpos;

 tempmess.ms_kind=messkind;
 as_cold(strlen(p_string)<=MESSMAXCH,
         "lister.add_mess: Parameter message is too long.");
 strcpy(tempmess.ms_text,p_string);
 ASSIGN(unqpos.up_pos,*p_pos);
 unqpos.up_serial=serial_next++;
 tb_ins(p_msgtab,PV &unqpos,PV &tempmess);
}

/******************************************************************************/

EXPORT void lr_ini P_((void))
{
 /* Create a brand new empty message table. */
 p_msgtab=tb_cre(sizeof(unqpos_t),sizeof(mess_t),(p_kycm_t) cmpuqpos);

 /* Start the serial numbers at zero again. */
 serial_next=0;
}

/******************************************************************************/

EXPORT void lr_mes(p_pos,s)
ps_t *p_pos;
char *s;
{
 add_mess(p_pos,MESS_MES,s);
}

/******************************************************************************/

EXPORT void lr_war(p_pos,s)
ps_t *p_pos;
char *s;
{
 add_mess(p_pos,MESS_WAR,s);
 num_war++;
}

/******************************************************************************/

EXPORT void lr_err(p_pos,s)
ps_t *p_pos;
char *s;
{
 add_mess(p_pos,MESS_ERR,s);
 num_err++;
}

/******************************************************************************/

EXPORT void lr_sev(p_pos,s)
ps_t *p_pos;
char *s;
{
 add_mess(p_pos,MESS_SEV,s);
 num_sev++;
}

/******************************************************************************/

EXPORT void lr_gen(p_wf,ctx)
p_wf_t p_wf;
uword  ctx;
{
 unqpos_t next_pos; /* Position of next message.                              */
 mess_t   next_mes; /* Content  of next message.                              */
 long     prev_no;  /* Global line number of previous message.                */
 long     next_no;  /* Global line number of next     message.                */
 bool     ingap;    /* Controls issuance of gap markers in the listing.       */
 long     context=ctx; /* Signed version of the parameter.                    */

 /* A context of CTXINF signals an infinite context. */
 if (context==CTXINF) context=MAXLINES;

 /* Write listing header. */
 wf_wr(p_wf,"\nGlobal Local| Input File\n");
 wf_wr(p_wf,dup('-',12));wf_wr(p_wf,"+");
 wf_wr(p_wf,dup('-',LISTWIDTH-13));wf_wr(p_wf,"\n");

 /* Reset the line list and message table for reading. */
 ls_fir(line_list);
 tb_fir(p_msgtab);

 /* Prime the variables ingap, prev_no, next_no, next_pos, and next_mes. */
 ingap=FALSE; prev_no = -(context+1);
 if (tb_rea(p_msgtab,PV &next_pos,PV &next_mes))
    next_no=next_pos.up_pos.ps_line;
 else
    next_no=MAXLINES+context+1;

 while (TRUE)
   {/* Process a single line per iteration. */
    ln_t *p_line;

    /* Grab the next line from the line list. */
    ls_nxt(line_list,PPV &p_line);
    if (p_line==NULL) break;

    /* List the line if it is within context range of prev or next message. */
    if ((((long) p_line->ln_global) <= prev_no+context) ||
        (((long) p_line->ln_global) >= next_no-context))
       {line_wri(p_wf,p_line);ingap=FALSE;}
    else
       if (!ingap)
          {wf_wr(p_wf,".................\n");ingap=TRUE;}

    /* Issue any messages that are about this line. */
    while (next_no == p_line->ln_global)
      {
       /* Write the current message. */
       mess_wri(p_wf,&next_mes,(uword) 0,
                (uword) next_pos.up_pos.ps_column);
                
       /* Read the next message from the table. */
       prev_no=next_no;
       if (tb_rea(p_msgtab,PV &next_pos,PV &next_mes))
          next_no=next_pos.up_pos.ps_line;
       else
          next_no=MAXLINES+context+1;
      }
   } /* End while */

 /* Make sure that we have read to the end of the message table. */
 {bool result;
  result=tb_rea(p_msgtab,PV &next_pos,PV &next_mes);
  as_cold(!result,
          "lr_gen: Messages remaining in message table after listing.");
 }

 /* Write listing trailer. */
 wf_wr(p_wf,dup('-',12));wf_wr(p_wf,"+");
 wf_wr(p_wf,dup('-',LISTWIDTH-13));wf_wr(p_wf,"\n");
 wf_wl(p_wf,"");
}

/******************************************************************************/
/*                               End of LISTER.C                              */
/******************************************************************************/