1 #ifndef Py_ERRORS_H 2 #define Py_ERRORS_H 3 #ifdef __cplusplus 4 extern "C" { 5 #endif 6 7 /* Error objects */ 8 9 #ifndef Py_LIMITED_API 10 /* PyException_HEAD defines the initial segment of every exception class. */ 11 #define PyException_HEAD PyObject_HEAD PyObject *dict;\ 12 PyObject *args; PyObject *traceback;\ 13 PyObject *context; PyObject *cause;\ 14 char suppress_context; 15 16 typedef struct { 17 PyException_HEAD 18 } PyBaseExceptionObject; 19 20 typedef struct { 21 PyException_HEAD 22 PyObject *msg; 23 PyObject *filename; 24 PyObject *lineno; 25 PyObject *offset; 26 PyObject *text; 27 PyObject *print_file_and_line; 28 } PySyntaxErrorObject; 29 30 typedef struct { 31 PyException_HEAD 32 PyObject *msg; 33 PyObject *name; 34 PyObject *path; 35 } PyImportErrorObject; 36 37 typedef struct { 38 PyException_HEAD 39 PyObject *encoding; 40 PyObject *object; 41 Py_ssize_t start; 42 Py_ssize_t end; 43 PyObject *reason; 44 } PyUnicodeErrorObject; 45 46 typedef struct { 47 PyException_HEAD 48 PyObject *code; 49 } PySystemExitObject; 50 51 typedef struct { 52 PyException_HEAD 53 PyObject *myerrno; 54 PyObject *strerror; 55 PyObject *filename; 56 PyObject *filename2; 57 #ifdef MS_WINDOWS 58 PyObject *winerror; 59 #endif 60 Py_ssize_t written; /* only for BlockingIOError, -1 otherwise */ 61 } PyOSErrorObject; 62 63 typedef struct { 64 PyException_HEAD 65 PyObject *value; 66 } PyStopIterationObject; 67 68 /* Compatibility typedefs */ 69 typedef PyOSErrorObject PyEnvironmentErrorObject; 70 #ifdef MS_WINDOWS 71 typedef PyOSErrorObject PyWindowsErrorObject; 72 #endif 73 #endif /* !Py_LIMITED_API */ 74 75 /* Error handling definitions */ 76 77 PyAPI_FUNC(void) PyErr_SetNone(PyObject *); 78 PyAPI_FUNC(void) PyErr_SetObject(PyObject *, PyObject *); 79 #ifndef Py_LIMITED_API 80 PyAPI_FUNC(void) _PyErr_SetKeyError(PyObject *); 81 #endif 82 PyAPI_FUNC(void) PyErr_SetString( 83 PyObject *exception, 84 const char *string /* decoded from utf-8 */ 85 ); 86 PyAPI_FUNC(PyObject *) PyErr_Occurred(void); 87 PyAPI_FUNC(void) PyErr_Clear(void); 88 PyAPI_FUNC(void) PyErr_Fetch(PyObject **, PyObject **, PyObject **); 89 PyAPI_FUNC(void) PyErr_Restore(PyObject *, PyObject *, PyObject *); 90 #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 91 PyAPI_FUNC(void) PyErr_GetExcInfo(PyObject **, PyObject **, PyObject **); 92 PyAPI_FUNC(void) PyErr_SetExcInfo(PyObject *, PyObject *, PyObject *); 93 #endif 94 95 #if defined(__clang__) || \ 96 (defined(__GNUC__) && \ 97 ((__GNUC__ >= 3) || \ 98 (__GNUC__ == 2) && (__GNUC_MINOR__ >= 5))) 99 #define _Py_NO_RETURN __attribute__((__noreturn__)) 100 #else 101 #define _Py_NO_RETURN 102 #endif 103 104 /* Defined in Python/pylifecycle.c */ 105 PyAPI_FUNC(void) Py_FatalError(const char *message) _Py_NO_RETURN; 106 107 #if defined(Py_DEBUG) || defined(Py_LIMITED_API) 108 #define _PyErr_OCCURRED() PyErr_Occurred() 109 #else 110 #define _PyErr_OCCURRED() (PyThreadState_GET()->curexc_type) 111 #endif 112 113 /* Error testing and normalization */ 114 PyAPI_FUNC(int) PyErr_GivenExceptionMatches(PyObject *, PyObject *); 115 PyAPI_FUNC(int) PyErr_ExceptionMatches(PyObject *); 116 PyAPI_FUNC(void) PyErr_NormalizeException(PyObject**, PyObject**, PyObject**); 117 118 /* Traceback manipulation (PEP 3134) */ 119 PyAPI_FUNC(int) PyException_SetTraceback(PyObject *, PyObject *); 120 PyAPI_FUNC(PyObject *) PyException_GetTraceback(PyObject *); 121 122 /* Cause manipulation (PEP 3134) */ 123 PyAPI_FUNC(PyObject *) PyException_GetCause(PyObject *); 124 PyAPI_FUNC(void) PyException_SetCause(PyObject *, PyObject *); 125 126 /* Context manipulation (PEP 3134) */ 127 PyAPI_FUNC(PyObject *) PyException_GetContext(PyObject *); 128 PyAPI_FUNC(void) PyException_SetContext(PyObject *, PyObject *); 129 #ifndef Py_LIMITED_API 130 PyAPI_FUNC(void) _PyErr_ChainExceptions(PyObject *, PyObject *, PyObject *); 131 #endif 132 133 /* */ 134 135 #define PyExceptionClass_Check(x) \ 136 (PyType_Check((x)) && \ 137 PyType_FastSubclass((PyTypeObject*)(x), Py_TPFLAGS_BASE_EXC_SUBCLASS)) 138 139 #define PyExceptionInstance_Check(x) \ 140 PyType_FastSubclass((x)->ob_type, Py_TPFLAGS_BASE_EXC_SUBCLASS) 141 142 #define PyExceptionClass_Name(x) \ 143 ((char *)(((PyTypeObject*)(x))->tp_name)) 144 145 #define PyExceptionInstance_Class(x) ((PyObject*)((x)->ob_type)) 146 147 148 /* Predefined exceptions */ 149 150 PyAPI_DATA(PyObject *) PyExc_BaseException; 151 PyAPI_DATA(PyObject *) PyExc_Exception; 152 #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000 153 PyAPI_DATA(PyObject *) PyExc_StopAsyncIteration; 154 #endif 155 PyAPI_DATA(PyObject *) PyExc_StopIteration; 156 PyAPI_DATA(PyObject *) PyExc_GeneratorExit; 157 PyAPI_DATA(PyObject *) PyExc_ArithmeticError; 158 PyAPI_DATA(PyObject *) PyExc_LookupError; 159 160 PyAPI_DATA(PyObject *) PyExc_AssertionError; 161 PyAPI_DATA(PyObject *) PyExc_AttributeError; 162 PyAPI_DATA(PyObject *) PyExc_BufferError; 163 PyAPI_DATA(PyObject *) PyExc_EOFError; 164 PyAPI_DATA(PyObject *) PyExc_FloatingPointError; 165 PyAPI_DATA(PyObject *) PyExc_OSError; 166 PyAPI_DATA(PyObject *) PyExc_ImportError; 167 #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000 168 PyAPI_DATA(PyObject *) PyExc_ModuleNotFoundError; 169 #endif 170 PyAPI_DATA(PyObject *) PyExc_IndexError; 171 PyAPI_DATA(PyObject *) PyExc_KeyError; 172 PyAPI_DATA(PyObject *) PyExc_KeyboardInterrupt; 173 PyAPI_DATA(PyObject *) PyExc_MemoryError; 174 PyAPI_DATA(PyObject *) PyExc_NameError; 175 PyAPI_DATA(PyObject *) PyExc_OverflowError; 176 PyAPI_DATA(PyObject *) PyExc_RuntimeError; 177 #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000 178 PyAPI_DATA(PyObject *) PyExc_RecursionError; 179 #endif 180 PyAPI_DATA(PyObject *) PyExc_NotImplementedError; 181 PyAPI_DATA(PyObject *) PyExc_SyntaxError; 182 PyAPI_DATA(PyObject *) PyExc_IndentationError; 183 PyAPI_DATA(PyObject *) PyExc_TabError; 184 PyAPI_DATA(PyObject *) PyExc_ReferenceError; 185 PyAPI_DATA(PyObject *) PyExc_SystemError; 186 PyAPI_DATA(PyObject *) PyExc_SystemExit; 187 PyAPI_DATA(PyObject *) PyExc_TypeError; 188 PyAPI_DATA(PyObject *) PyExc_UnboundLocalError; 189 PyAPI_DATA(PyObject *) PyExc_UnicodeError; 190 PyAPI_DATA(PyObject *) PyExc_UnicodeEncodeError; 191 PyAPI_DATA(PyObject *) PyExc_UnicodeDecodeError; 192 PyAPI_DATA(PyObject *) PyExc_UnicodeTranslateError; 193 PyAPI_DATA(PyObject *) PyExc_ValueError; 194 PyAPI_DATA(PyObject *) PyExc_ZeroDivisionError; 195 196 #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 197 PyAPI_DATA(PyObject *) PyExc_BlockingIOError; 198 PyAPI_DATA(PyObject *) PyExc_BrokenPipeError; 199 PyAPI_DATA(PyObject *) PyExc_ChildProcessError; 200 PyAPI_DATA(PyObject *) PyExc_ConnectionError; 201 PyAPI_DATA(PyObject *) PyExc_ConnectionAbortedError; 202 PyAPI_DATA(PyObject *) PyExc_ConnectionRefusedError; 203 PyAPI_DATA(PyObject *) PyExc_ConnectionResetError; 204 PyAPI_DATA(PyObject *) PyExc_FileExistsError; 205 PyAPI_DATA(PyObject *) PyExc_FileNotFoundError; 206 PyAPI_DATA(PyObject *) PyExc_InterruptedError; 207 PyAPI_DATA(PyObject *) PyExc_IsADirectoryError; 208 PyAPI_DATA(PyObject *) PyExc_NotADirectoryError; 209 PyAPI_DATA(PyObject *) PyExc_PermissionError; 210 PyAPI_DATA(PyObject *) PyExc_ProcessLookupError; 211 PyAPI_DATA(PyObject *) PyExc_TimeoutError; 212 #endif 213 214 215 /* Compatibility aliases */ 216 PyAPI_DATA(PyObject *) PyExc_EnvironmentError; 217 PyAPI_DATA(PyObject *) PyExc_IOError; 218 #ifdef MS_WINDOWS 219 PyAPI_DATA(PyObject *) PyExc_WindowsError; 220 #endif 221 222 /* Predefined warning categories */ 223 PyAPI_DATA(PyObject *) PyExc_Warning; 224 PyAPI_DATA(PyObject *) PyExc_UserWarning; 225 PyAPI_DATA(PyObject *) PyExc_DeprecationWarning; 226 PyAPI_DATA(PyObject *) PyExc_PendingDeprecationWarning; 227 PyAPI_DATA(PyObject *) PyExc_SyntaxWarning; 228 PyAPI_DATA(PyObject *) PyExc_RuntimeWarning; 229 PyAPI_DATA(PyObject *) PyExc_FutureWarning; 230 PyAPI_DATA(PyObject *) PyExc_ImportWarning; 231 PyAPI_DATA(PyObject *) PyExc_UnicodeWarning; 232 PyAPI_DATA(PyObject *) PyExc_BytesWarning; 233 PyAPI_DATA(PyObject *) PyExc_ResourceWarning; 234 235 236 /* Convenience functions */ 237 238 PyAPI_FUNC(int) PyErr_BadArgument(void); 239 PyAPI_FUNC(PyObject *) PyErr_NoMemory(void); 240 PyAPI_FUNC(PyObject *) PyErr_SetFromErrno(PyObject *); 241 PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithFilenameObject( 242 PyObject *, PyObject *); 243 #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03040000 244 PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithFilenameObjects( 245 PyObject *, PyObject *, PyObject *); 246 #endif 247 PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithFilename( 248 PyObject *exc, 249 const char *filename /* decoded from the filesystem encoding */ 250 ); 251 #if defined(MS_WINDOWS) && !defined(Py_LIMITED_API) 252 PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithUnicodeFilename( 253 PyObject *, const Py_UNICODE *); 254 #endif /* MS_WINDOWS */ 255 256 PyAPI_FUNC(PyObject *) PyErr_Format( 257 PyObject *exception, 258 const char *format, /* ASCII-encoded string */ 259 ... 260 ); 261 #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000 262 PyAPI_FUNC(PyObject *) PyErr_FormatV( 263 PyObject *exception, 264 const char *format, 265 va_list vargs); 266 #endif 267 268 #ifndef Py_LIMITED_API 269 /* Like PyErr_Format(), but saves current exception as __context__ and 270 __cause__. 271 */ 272 PyAPI_FUNC(PyObject *) _PyErr_FormatFromCause( 273 PyObject *exception, 274 const char *format, /* ASCII-encoded string */ 275 ... 276 ); 277 #endif 278 279 #ifdef MS_WINDOWS 280 PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErrWithFilename( 281 int ierr, 282 const char *filename /* decoded from the filesystem encoding */ 283 ); 284 #ifndef Py_LIMITED_API 285 /* XXX redeclare to use WSTRING */ 286 PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErrWithUnicodeFilename( 287 int, const Py_UNICODE *); 288 #endif 289 PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErr(int); 290 PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithFilenameObject( 291 PyObject *,int, PyObject *); 292 #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03040000 293 PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithFilenameObjects( 294 PyObject *,int, PyObject *, PyObject *); 295 #endif 296 PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithFilename( 297 PyObject *exc, 298 int ierr, 299 const char *filename /* decoded from the filesystem encoding */ 300 ); 301 #ifndef Py_LIMITED_API 302 PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithUnicodeFilename( 303 PyObject *,int, const Py_UNICODE *); 304 #endif 305 PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErr(PyObject *, int); 306 #endif /* MS_WINDOWS */ 307 308 #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000 309 PyAPI_FUNC(PyObject *) PyErr_SetImportErrorSubclass(PyObject *, PyObject *, 310 PyObject *, PyObject *); 311 #endif 312 #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 313 PyAPI_FUNC(PyObject *) PyErr_SetImportError(PyObject *, PyObject *, 314 PyObject *); 315 #endif 316 317 /* Export the old function so that the existing API remains available: */ 318 PyAPI_FUNC(void) PyErr_BadInternalCall(void); 319 PyAPI_FUNC(void) _PyErr_BadInternalCall(const char *filename, int lineno); 320 /* Mask the old API with a call to the new API for code compiled under 321 Python 2.0: */ 322 #define PyErr_BadInternalCall() _PyErr_BadInternalCall(__FILE__, __LINE__) 323 324 /* Function to create a new exception */ 325 PyAPI_FUNC(PyObject *) PyErr_NewException( 326 const char *name, PyObject *base, PyObject *dict); 327 PyAPI_FUNC(PyObject *) PyErr_NewExceptionWithDoc( 328 const char *name, const char *doc, PyObject *base, PyObject *dict); 329 PyAPI_FUNC(void) PyErr_WriteUnraisable(PyObject *); 330 331 /* In exceptions.c */ 332 #ifndef Py_LIMITED_API 333 /* Helper that attempts to replace the current exception with one of the 334 * same type but with a prefix added to the exception text. The resulting 335 * exception description looks like: 336 * 337 * prefix (exc_type: original_exc_str) 338 * 339 * Only some exceptions can be safely replaced. If the function determines 340 * it isn't safe to perform the replacement, it will leave the original 341 * unmodified exception in place. 342 * 343 * Returns a borrowed reference to the new exception (if any), NULL if the 344 * existing exception was left in place. 345 */ 346 PyAPI_FUNC(PyObject *) _PyErr_TrySetFromCause( 347 const char *prefix_format, /* ASCII-encoded string */ 348 ... 349 ); 350 #endif 351 352 353 /* In sigcheck.c or signalmodule.c */ 354 PyAPI_FUNC(int) PyErr_CheckSignals(void); 355 PyAPI_FUNC(void) PyErr_SetInterrupt(void); 356 357 /* In signalmodule.c */ 358 #ifndef Py_LIMITED_API 359 int PySignal_SetWakeupFd(int fd); 360 #endif 361 362 /* Support for adding program text to SyntaxErrors */ 363 PyAPI_FUNC(void) PyErr_SyntaxLocation( 364 const char *filename, /* decoded from the filesystem encoding */ 365 int lineno); 366 PyAPI_FUNC(void) PyErr_SyntaxLocationEx( 367 const char *filename, /* decoded from the filesystem encoding */ 368 int lineno, 369 int col_offset); 370 #ifndef Py_LIMITED_API 371 PyAPI_FUNC(void) PyErr_SyntaxLocationObject( 372 PyObject *filename, 373 int lineno, 374 int col_offset); 375 #endif 376 PyAPI_FUNC(PyObject *) PyErr_ProgramText( 377 const char *filename, /* decoded from the filesystem encoding */ 378 int lineno); 379 #ifndef Py_LIMITED_API 380 PyAPI_FUNC(PyObject *) PyErr_ProgramTextObject( 381 PyObject *filename, 382 int lineno); 383 #endif 384 385 /* The following functions are used to create and modify unicode 386 exceptions from C */ 387 388 /* create a UnicodeDecodeError object */ 389 PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_Create( 390 const char *encoding, /* UTF-8 encoded string */ 391 const char *object, 392 Py_ssize_t length, 393 Py_ssize_t start, 394 Py_ssize_t end, 395 const char *reason /* UTF-8 encoded string */ 396 ); 397 398 /* create a UnicodeEncodeError object */ 399 #ifndef Py_LIMITED_API 400 PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_Create( 401 const char *encoding, /* UTF-8 encoded string */ 402 const Py_UNICODE *object, 403 Py_ssize_t length, 404 Py_ssize_t start, 405 Py_ssize_t end, 406 const char *reason /* UTF-8 encoded string */ 407 ); 408 #endif 409 410 /* create a UnicodeTranslateError object */ 411 #ifndef Py_LIMITED_API 412 PyAPI_FUNC(PyObject *) PyUnicodeTranslateError_Create( 413 const Py_UNICODE *object, 414 Py_ssize_t length, 415 Py_ssize_t start, 416 Py_ssize_t end, 417 const char *reason /* UTF-8 encoded string */ 418 ); 419 PyAPI_FUNC(PyObject *) _PyUnicodeTranslateError_Create( 420 PyObject *object, 421 Py_ssize_t start, 422 Py_ssize_t end, 423 const char *reason /* UTF-8 encoded string */ 424 ); 425 #endif 426 427 /* get the encoding attribute */ 428 PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_GetEncoding(PyObject *); 429 PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_GetEncoding(PyObject *); 430 431 /* get the object attribute */ 432 PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_GetObject(PyObject *); 433 PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_GetObject(PyObject *); 434 PyAPI_FUNC(PyObject *) PyUnicodeTranslateError_GetObject(PyObject *); 435 436 /* get the value of the start attribute (the int * may not be NULL) 437 return 0 on success, -1 on failure */ 438 PyAPI_FUNC(int) PyUnicodeEncodeError_GetStart(PyObject *, Py_ssize_t *); 439 PyAPI_FUNC(int) PyUnicodeDecodeError_GetStart(PyObject *, Py_ssize_t *); 440 PyAPI_FUNC(int) PyUnicodeTranslateError_GetStart(PyObject *, Py_ssize_t *); 441 442 /* assign a new value to the start attribute 443 return 0 on success, -1 on failure */ 444 PyAPI_FUNC(int) PyUnicodeEncodeError_SetStart(PyObject *, Py_ssize_t); 445 PyAPI_FUNC(int) PyUnicodeDecodeError_SetStart(PyObject *, Py_ssize_t); 446 PyAPI_FUNC(int) PyUnicodeTranslateError_SetStart(PyObject *, Py_ssize_t); 447 448 /* get the value of the end attribute (the int *may not be NULL) 449 return 0 on success, -1 on failure */ 450 PyAPI_FUNC(int) PyUnicodeEncodeError_GetEnd(PyObject *, Py_ssize_t *); 451 PyAPI_FUNC(int) PyUnicodeDecodeError_GetEnd(PyObject *, Py_ssize_t *); 452 PyAPI_FUNC(int) PyUnicodeTranslateError_GetEnd(PyObject *, Py_ssize_t *); 453 454 /* assign a new value to the end attribute 455 return 0 on success, -1 on failure */ 456 PyAPI_FUNC(int) PyUnicodeEncodeError_SetEnd(PyObject *, Py_ssize_t); 457 PyAPI_FUNC(int) PyUnicodeDecodeError_SetEnd(PyObject *, Py_ssize_t); 458 PyAPI_FUNC(int) PyUnicodeTranslateError_SetEnd(PyObject *, Py_ssize_t); 459 460 /* get the value of the reason attribute */ 461 PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_GetReason(PyObject *); 462 PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_GetReason(PyObject *); 463 PyAPI_FUNC(PyObject *) PyUnicodeTranslateError_GetReason(PyObject *); 464 465 /* assign a new value to the reason attribute 466 return 0 on success, -1 on failure */ 467 PyAPI_FUNC(int) PyUnicodeEncodeError_SetReason( 468 PyObject *exc, 469 const char *reason /* UTF-8 encoded string */ 470 ); 471 PyAPI_FUNC(int) PyUnicodeDecodeError_SetReason( 472 PyObject *exc, 473 const char *reason /* UTF-8 encoded string */ 474 ); 475 PyAPI_FUNC(int) PyUnicodeTranslateError_SetReason( 476 PyObject *exc, 477 const char *reason /* UTF-8 encoded string */ 478 ); 479 480 /* These APIs aren't really part of the error implementation, but 481 often needed to format error messages; the native C lib APIs are 482 not available on all platforms, which is why we provide emulations 483 for those platforms in Python/mysnprintf.c, 484 WARNING: The return value of snprintf varies across platforms; do 485 not rely on any particular behavior; eventually the C99 defn may 486 be reliable. 487 */ 488 #if defined(MS_WIN32) && !defined(HAVE_SNPRINTF) 489 # define HAVE_SNPRINTF 490 # define snprintf _snprintf 491 # define vsnprintf _vsnprintf 492 #endif 493 494 #include <stdarg.h> 495 PyAPI_FUNC(int) PyOS_snprintf(char *str, size_t size, const char *format, ...) 496 Py_GCC_ATTRIBUTE((format(printf, 3, 4))); 497 PyAPI_FUNC(int) PyOS_vsnprintf(char *str, size_t size, const char *format, va_list va) 498 Py_GCC_ATTRIBUTE((format(printf, 3, 0))); 499 500 #ifdef __cplusplus 501 } 502 #endif 503 #endif /* !Py_ERRORS_H */ 504