← Back to branch summary

~burner/xsb/debianized-xsb

« back to all changes in this revision

Viewing changes to packages/sgml/cc/error.c

  • Committer: Michael R. Head
  • Date: 2006-09-06 22:11:55 UTC
  • Revision ID: burner@n23-20060906221155-7e398d23438a7ee4
Add the files from the 3.0.1 release package

Show diffs side-by-side

added added

removed removed

Lines of Context:
packages/sgml/cc/error.c
 
1
/*****************************************************************************
 
2
 *                            error.c
 
3
 * This function contains the error handling routine of the sgml parser. This
 
4
 * routine creates the error term to throw in case of an exception.
 
5
 *
 
6
 ***************************************************************************/
 
7
 
 
8
#include <errno.h>
 
9
#include <stdlib.h>
 
10
#include "error.h"
 
11
#include <assert.h>
 
12
#include <string.h>
 
13
#include <stdio.h>
 
14
#include "cinterf.h"
 
15
#include "dtd.h"
 
16
#include "error_term.h"
 
17
 
 
18
prolog_term global_error_term = (prolog_term)NULL;
 
19
prolog_term global_warning_term = (prolog_term)NULL;
 
20
 
 
21
/**
 
22
 * Function to handle the errors. It creates an appropriate error term 
 
23
 * for the prolog side to throw.
 
24
 * Input : type of error
 
25
 * Output : TRUE on success, FALSE on failure
 
26
 **/
 
27
int
 
28
sgml2pl_error(plerrorid id, ...)
 
29
{ 
 
30
  prolog_term except = p2p_new();
 
31
  prolog_term formal = p2p_new();
 
32
  prolog_term swi = p2p_new();
 
33
  prolog_term tmp1 = p2p_new();
 
34
  prolog_term tmp;
 
35
 
 
36
  va_list args;
 
37
  char msgbuf[1024];
 
38
  char *msg = NULL;
 
39
 
 
40
  va_start(args, id);
 
41
  /*Create the appropriate error term based on the type of error*/
 
42
  switch(id)
 
43
    { 
 
44
    case ERR_ERRNO:                                     /*Standard unix errors*/
 
45
      { 
 
46
        int err = va_arg(args, int);
 
47
        msg = strerror(err);
 
48
 
 
49
          switch(err)
 
50
            { 
 
51
              /*Not enough memory error*/
 
52
            case ENOMEM:
 
53
          
 
54
              c2p_functor("sgml", 1, tmp1);     
 
55
              tmp = p2p_arg( tmp1, 1);
 
56
              c2p_functor( "resource_error", 1, tmp);
 
57
          
 
58
              c2p_string( "no_memory", p2p_arg( tmp, 1));
 
59
              p2p_unify( tmp1, formal); 
 
60
              break;
 
61
              /*No access error*/
 
62
            case EACCES:
 
63
              { 
 
64
                const char *file = va_arg(args,   const char *);
 
65
                const char *action = va_arg(args, const char *);
 
66
 
 
67
                c2p_functor("sgml", 1, tmp1);
 
68
                tmp = p2p_arg( tmp1, 1);
 
69
 
 
70
                c2p_functor( "permission_error", 3, tmp);
 
71
                c2p_string( (char*)action, p2p_arg(tmp, 1));
 
72
                c2p_string( "file", p2p_arg(tmp, 2));
 
73
                c2p_string ( (char*)file, p2p_arg(tmp, 3));
 
74
 
 
75
                p2p_unify( tmp1, formal);
 
76
                break;
 
77
              }
 
78
              /*Entity not found error*/
 
79
            case ENOENT:
 
80
              { 
 
81
                const char *file = va_arg(args, const char *);
 
82
         
 
83
 
 
84
                c2p_functor("sgml", 1, tmp1);
 
85
                tmp = p2p_arg( tmp1, 1);
 
86
 
 
87
                c2p_functor( "permission_error", 2, tmp);
 
88
                          
 
89
                c2p_string( "file", p2p_arg(tmp, 1));
 
90
                c2p_string ( (char*)file, p2p_arg(tmp, 2));
 
91
 
 
92
                p2p_unify( tmp1, formal); 
 
93
 
 
94
                break;
 
95
              }
 
96
              /*Defaults to system error*/
 
97
            default:
 
98
              {
 
99
                c2p_functor("sgml", 1, tmp1);
 
100
                tmp = p2p_arg( tmp1, 1);
 
101
 
 
102
                c2p_string("system_error", tmp);
 
103
                p2p_unify( tmp1, formal);
 
104
                break;
 
105
              }
 
106
            }
 
107
          break;
 
108
        }
 
109
    case ERR_TYPE:
 
110
      { 
 
111
        const char *expected = va_arg(args, const char*);
 
112
        prolog_term actual        = va_arg(args, prolog_term);
 
113
 
 
114
 
 
115
        /*Type error*/
 
116
        c2p_functor("sgml", 1, tmp1);
 
117
        tmp = p2p_arg( tmp1, 1);
 
118
 
 
119
        if( is_attv( actual) && strcmp(expected, "variable") != 0 )
 
120
          {
 
121
            c2p_string( "instantiation_error", tmp);
 
122
            p2p_unify( tmp1, formal);
 
123
          }
 
124
        else
 
125
          {
 
126
            c2p_functor( "type_error", 2, tmp);
 
127
            c2p_string( (char*)expected, p2p_arg(tmp, 1));
 
128
            p2p_unify ( actual, p2p_arg(tmp, 2));
 
129
            p2p_unify( tmp1, formal);
 
130
          }
 
131
        break;
 
132
      } 
 
133
    case ERR_DOMAIN:                            /*Domain error*/
 
134
      { 
 
135
        const char *expected = va_arg(args, const char*);
 
136
        prolog_term actual        = va_arg(args, prolog_term);
 
137
 
 
138
        /*Improper domain of functor*/
 
139
        c2p_functor("sgml", 1, tmp1);
 
140
        tmp = p2p_arg( tmp1, 1);
 
141
        
 
142
        if( is_attv( actual) && strcmp(expected, "variable") != 0 )
 
143
          {
 
144
            c2p_string( "instantiation_error", tmp);
 
145
            p2p_unify( tmp1, formal);
 
146
          }
 
147
        else
 
148
          {
 
149
            c2p_functor( "domain_error", 2, tmp);
 
150
            c2p_string( (char*)expected, p2p_arg(tmp, 1));
 
151
            p2p_unify( actual, p2p_arg(tmp, 2));
 
152
            p2p_unify( tmp1, formal);
 
153
          }
 
154
        break;
 
155
      }
 
156
    case ERR_EXISTENCE:                 /*Existence error*/
 
157
      { 
 
158
        const char *type = va_arg(args, const char *);
 
159
        prolog_term obj  = va_arg(args, prolog_term);
 
160
 
 
161
        /*Resource not found*/
 
162
        c2p_functor("sgml", 1, tmp1);
 
163
        tmp = p2p_arg( tmp1, 1);
 
164
 
 
165
        c2p_functor( "existence_error", 2, tmp);
 
166
                                                                              
 
167
        c2p_string( (char*)type, p2p_arg(tmp, 1));
 
168
        p2p_unify ( obj, p2p_arg(tmp, 2));
 
169
                                                                                
 
170
        p2p_unify( tmp1, formal);
 
171
        break;
 
172
      }
 
173
    case ERR_FAIL:
 
174
      { 
 
175
        /*Goal failed error*/
 
176
        prolog_term goal  = va_arg(args, prolog_term);
 
177
 
 
178
        c2p_functor("sgml", 1, tmp1);
 
179
        tmp = p2p_arg( tmp1, 1);
 
180
 
 
181
        c2p_functor( "goal_failed", 1, tmp);
 
182
 
 
183
        p2p_unify( p2p_arg( tmp,1), goal);      
 
184
      
 
185
        p2p_unify( tmp1, formal);
 
186
        break;
 
187
      }
 
188
    case ERR_LIMIT:
 
189
      { 
 
190
        /*Limit exceeded error*/
 
191
        const char *limit = va_arg(args, const char *);
 
192
        long maxval  = va_arg(args, long);
 
193
 
 
194
        c2p_functor("sgml", 1, tmp1);
 
195
        tmp = p2p_arg( tmp1, 1);
 
196
        
 
197
        c2p_functor( "limit_exceeded", 2, tmp);
 
198
        c2p_string( (char*)limit, p2p_arg( tmp,1));
 
199
        c2p_int( maxval, p2p_arg( tmp, 2));
 
200
        p2p_unify( tmp1, formal);
 
201
        break;
 
202
      }
 
203
    case ERR_MISC:
 
204
      { 
 
205
        /*Miscellaneous error*/
 
206
        const char *id = va_arg(args, const char *);
 
207
      
 
208
        const char *fmt = va_arg(args, const char *);
 
209
 
 
210
        vsprintf(msgbuf, fmt, args);
 
211
        msg = msgbuf;
 
212
 
 
213
        c2p_functor("sgml", 1, tmp1);
 
214
        tmp = p2p_arg( tmp1, 1);
 
215
 
 
216
        c2p_functor( "miscellaneous", 1, tmp);
 
217
        c2p_string( (char*)id, p2p_arg( tmp, 1));
 
218
        p2p_unify( tmp1, formal);
 
219
        break; 
 
220
      }
 
221
    default:
 
222
      assert(0);
 
223
    }
 
224
 
 
225
  va_end(args);
 
226
 
 
227
  if ( msg )
 
228
    { 
 
229
      prolog_term msgterm  = p2p_new();
 
230
 
 
231
      if ( msg )
 
232
        { 
 
233
          c2p_string( msg, msgterm);
 
234
        }
 
235
 
 
236
      tmp = p2p_new();
 
237
 
 
238
      c2p_functor( "context", 1, tmp);
 
239
      p2p_unify( p2p_arg( tmp, 1), msgterm);    
 
240
      p2p_unify( tmp, swi);
 
241
    }
 
242
 
 
243
  /*Create the error term to throw*/
 
244
  tmp = p2p_new();
 
245
  c2p_functor( "error", 2, tmp);
 
246
  p2p_unify( p2p_arg( tmp, 1), formal);
 
247
  p2p_unify( p2p_arg( tmp, 2), swi);
 
248
  p2p_unify( tmp, except);
 
249
  
 
250
  return p2p_unify( global_error_term, except);
 
251
}
 
252