← Back to branch summary

~valavanisalex/ubuntu/oneiric/inkscape/inkscape_0.48.1-2ubuntu4

« back to all changes in this revision

Viewing changes to src/extension/script/CXX/Exception.hxx

  • Committer: Bazaar Package Importer
  • Author(s): Kees Cook, Ted Gould, Kees Cook
  • Date: 2009-06-24 14:00:43 UTC
  • mfrom: (1.1.8 upstream)
  • Revision ID: james.westby@ubuntu.com-20090624140043-07stp20mry48hqup
Tags: 0.47~pre0-0ubuntu1
* New upstream release

[ Ted Gould ]
* debian/control: Adding libgsl0 and removing version specifics on boost

[ Kees Cook ]
* debian/watch: updated to run uupdate and mangle pre-release versions.
* Dropped patches that have been taken upstream:
  - 01_mips
  - 02-poppler-0.8.3
  - 03-chinese-inkscape
  - 05_fix_latex_patch
  - 06_gcc-4.4
  - 07_cdr2svg
  - 08_skip-bad-utf-on-pdf-import
  - 09_gtk-clist
  - 10_belarussian
  - 11_libpng
  - 12_desktop
  - 13_slider
  - 100_svg_import_improvements
  - 102_sp_pattern_painter_free
  - 103_bitmap_type_print

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/extension/script/CXX/Exception.hxx
1
 
//-----------------------------------------------------------------------------
2
 
//
3
 
// Copyright (c) 1998 - 2007, The Regents of the University of California
4
 
// Produced at the Lawrence Livermore National Laboratory
5
 
// All rights reserved.
6
 
//
7
 
// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The
8
 
// full copyright notice is contained in the file COPYRIGHT located at the root
9
 
// of the PyCXX distribution.
10
 
//
11
 
// Redistribution  and  use  in  source  and  binary  forms,  with  or  without
12
 
// modification, are permitted provided that the following conditions are met:
13
 
//
14
 
//  - Redistributions of  source code must  retain the above  copyright notice,
15
 
//    this list of conditions and the disclaimer below.
16
 
//  - Redistributions in binary form must reproduce the above copyright notice,
17
 
//    this  list of  conditions  and  the  disclaimer (as noted below)  in  the
18
 
//    documentation and/or materials provided with the distribution.
19
 
//  - Neither the name of the UC/LLNL nor  the names of its contributors may be
20
 
//    used to  endorse or  promote products derived from  this software without
21
 
//    specific prior written permission.
22
 
//
23
 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT  HOLDERS AND CONTRIBUTORS "AS IS"
24
 
// AND ANY EXPRESS OR  IMPLIED WARRANTIES, INCLUDING,  BUT NOT  LIMITED TO, THE
25
 
// IMPLIED WARRANTIES OF MERCHANTABILITY AND  FITNESS FOR A PARTICULAR  PURPOSE
26
 
// ARE  DISCLAIMED.  IN  NO  EVENT  SHALL  THE  REGENTS  OF  THE  UNIVERSITY OF
27
 
// CALIFORNIA, THE U.S.  DEPARTMENT  OF  ENERGY OR CONTRIBUTORS BE  LIABLE  FOR
28
 
// ANY  DIRECT,  INDIRECT,  INCIDENTAL,  SPECIAL,  EXEMPLARY,  OR CONSEQUENTIAL
29
 
// DAMAGES (INCLUDING, BUT NOT  LIMITED TO, PROCUREMENT OF  SUBSTITUTE GOODS OR
30
 
// SERVICES; LOSS OF  USE, DATA, OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER
31
 
// CAUSED  AND  ON  ANY  THEORY  OF  LIABILITY,  WHETHER  IN  CONTRACT,  STRICT
32
 
// LIABILITY, OR TORT  (INCLUDING NEGLIGENCE OR OTHERWISE)  ARISING IN ANY  WAY
33
 
// OUT OF THE  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
34
 
// DAMAGE.
35
 
//
36
 
//-----------------------------------------------------------------------------
37
 
 
38
 
#ifndef __CXX_Exception_h
39
 
#define __CXX_Exception_h
40
 
 
41
 
#include "CXX/WrapPython.h"
42
 
#include "CXX/Version.hxx"
43
 
#include "CXX/Config.hxx"
44
 
#include "CXX/IndirectPythonInterface.hxx"
45
 
 
46
 
#include <string>
47
 
#include <iostream>
48
 
 
49
 
// This mimics the Python structure, in order to minimize confusion
50
 
namespace Py
51
 
{
52
 
    class ExtensionExceptionType;
53
 
 
54
 
    class Object;
55
 
 
56
 
    class Exception
57
 
    {
58
 
    public:
59
 
        Exception( ExtensionExceptionType &exception, const std::string& reason );
60
 
        Exception( ExtensionExceptionType &exception, Object &reason );
61
 
 
62
 
        explicit Exception ()
63
 
        {}
64
 
        
65
 
        Exception (const std::string& reason)
66
 
        {
67
 
            PyErr_SetString (Py::_Exc_RuntimeError(), reason.c_str());
68
 
        }
69
 
        
70
 
        Exception (PyObject* exception, const std::string& reason)
71
 
        {
72
 
            PyErr_SetString (exception, reason.c_str());
73
 
        }
74
 
        
75
 
        Exception (PyObject* exception, Object &reason);        
76
 
 
77
 
        void clear() // clear the error
78
 
        // technically but not philosophically const
79
 
        {
80
 
            PyErr_Clear();
81
 
        }
82
 
    };
83
 
    
84
 
    
85
 
    // Abstract
86
 
    class StandardError: public Exception
87
 
    {
88
 
    protected: 
89
 
        explicit StandardError()
90
 
        {}
91
 
    };
92
 
    
93
 
    class LookupError: public StandardError
94
 
    {
95
 
    protected: 
96
 
        explicit LookupError()
97
 
        {}
98
 
    };
99
 
    
100
 
    class ArithmeticError: public StandardError
101
 
    {
102
 
    protected: 
103
 
        explicit ArithmeticError()
104
 
        {}
105
 
    };
106
 
    
107
 
    class EnvironmentError: public StandardError
108
 
    {
109
 
    protected: 
110
 
        explicit EnvironmentError()
111
 
        {}
112
 
    };
113
 
    
114
 
    // Concrete
115
 
    
116
 
    class TypeError: public StandardError
117
 
    {
118
 
    public:
119
 
        TypeError (const std::string& reason)
120
 
            : StandardError()
121
 
        {
122
 
            PyErr_SetString (Py::_Exc_TypeError(),reason.c_str());
123
 
        }
124
 
    };
125
 
    
126
 
    class IndexError: public LookupError
127
 
    {
128
 
    public:
129
 
        IndexError (const std::string& reason)
130
 
            : LookupError()
131
 
        {
132
 
            PyErr_SetString (Py::_Exc_IndexError(), reason.c_str());
133
 
        }
134
 
    };
135
 
    
136
 
    class AttributeError: public StandardError
137
 
    {
138
 
    public:
139
 
        AttributeError (const std::string& reason)
140
 
            : StandardError()
141
 
        {
142
 
            PyErr_SetString (Py::_Exc_AttributeError(), reason.c_str());
143
 
        }        
144
 
    };
145
 
    
146
 
    class NameError: public StandardError
147
 
    {
148
 
    public:
149
 
        NameError (const std::string& reason)
150
 
            : StandardError()
151
 
        {
152
 
            PyErr_SetString (Py::_Exc_NameError(), reason.c_str());
153
 
        }
154
 
    };
155
 
    
156
 
    class RuntimeError: public StandardError
157
 
    {
158
 
    public:
159
 
        RuntimeError (const std::string& reason)
160
 
            : StandardError()
161
 
        {
162
 
            PyErr_SetString (Py::_Exc_RuntimeError(), reason.c_str());
163
 
        }
164
 
    };
165
 
    
166
 
    class SystemError: public StandardError
167
 
    {
168
 
    public:
169
 
        SystemError (const std::string& reason)
170
 
            : StandardError()
171
 
        {
172
 
            PyErr_SetString (Py::_Exc_SystemError(),reason.c_str());
173
 
        }
174
 
    };
175
 
    
176
 
    class KeyError: public LookupError
177
 
    {
178
 
    public:
179
 
        KeyError (const std::string& reason)
180
 
            : LookupError()
181
 
        {
182
 
            PyErr_SetString (Py::_Exc_KeyError(),reason.c_str());
183
 
        }
184
 
    };
185
 
    
186
 
    
187
 
    class ValueError: public StandardError
188
 
    {
189
 
    public:
190
 
        ValueError (const std::string& reason)
191
 
            : StandardError()
192
 
        {
193
 
            PyErr_SetString (Py::_Exc_ValueError(), reason.c_str());
194
 
        }
195
 
    };
196
 
    
197
 
    class OverflowError: public ArithmeticError
198
 
    {
199
 
    public:
200
 
        OverflowError (const std::string& reason)
201
 
            : ArithmeticError()
202
 
        {
203
 
            PyErr_SetString (Py::_Exc_OverflowError(), reason.c_str());
204
 
        }        
205
 
    };
206
 
    
207
 
    class ZeroDivisionError: public ArithmeticError
208
 
    {
209
 
    public:
210
 
        ZeroDivisionError (const std::string& reason)
211
 
            : ArithmeticError() 
212
 
        {
213
 
            PyErr_SetString (Py::_Exc_ZeroDivisionError(), reason.c_str());
214
 
        }
215
 
    };
216
 
    
217
 
    class FloatingPointError: public ArithmeticError
218
 
    {
219
 
    public:
220
 
        FloatingPointError (const std::string& reason)
221
 
            : ArithmeticError() 
222
 
        {
223
 
            PyErr_SetString (Py::_Exc_FloatingPointError(), reason.c_str());
224
 
        }
225
 
    };
226
 
    
227
 
    class MemoryError: public StandardError
228
 
    {
229
 
    public:
230
 
        MemoryError (const std::string& reason)
231
 
            : StandardError()
232
 
        {
233
 
            PyErr_SetString (Py::_Exc_MemoryError(), reason.c_str());
234
 
        }    
235
 
    };
236
 
    
237
 
    class SystemExit: public StandardError
238
 
    {
239
 
    public:
240
 
        SystemExit (const std::string& reason)
241
 
            : StandardError() 
242
 
        {
243
 
            PyErr_SetString (Py::_Exc_SystemExit(),reason.c_str());
244
 
        }
245
 
    };
246
 
 
247
 
}// Py
248
 
 
249
 
#endif