StoreTyped(PythonExceptions.BaseException exc)
{
IntPtr ptr = this.allocator.Alloc((uint)Marshal.SizeOf(typeof(PyObject)));
CPyMarshal.WriteIntField(ptr, typeof(PyObject), "ob_refcnt", 1);
object type_ = PythonCalls.Call(Builtin.type, new object[] { exc });
CPyMarshal.WritePtrField(ptr, typeof(PyObject), "ob_type", this.Store(type_));
this.map.Associate(ptr, exc);
return ptr;
}
public object GetObjectFromId(int id)
{
object o = mapping.GetObjectFromId(id);
if (o == null)
{
throw PythonExceptions.CreateThrowable(PythonExceptions.OSError, 9, "Bad file descriptor");
}
return(o);
}
public void release(CodeContext /*!*/ context)
{
if (Interlocked.Exchange <Coroutine>(ref curHolder, null) == null)
{
throw PythonExceptions.CreateThrowable((PythonType)PythonContext.GetContext(context).GetModuleState("coroutineerror"), "lock isn't held", null);
}
if (blockEvent != null)
{
// if this isn't set yet we race, it's handled in Acquire()
blockEvent.Set();
GC.KeepAlive(this);
}
}
private void DispatchTrace(List <FunctionStack> thread, Debugging.TraceEventKind kind, object payload, TracebackDelegate traceDispatch, object traceDispatchObject, TraceBackFrame pyFrame)
{
object args = null;
// Prepare the event
string traceEvent = String.Empty;
switch (kind)
{
case Debugging.TraceEventKind.FrameEnter: traceEvent = "call"; break;
case Debugging.TraceEventKind.TracePoint: traceEvent = "line"; break;
case Debugging.TraceEventKind.Exception:
traceEvent = "exception";
object pyException = PythonExceptions.ToPython((Exception)payload);
object pyType = ((IPythonObject)pyException).PythonType;
args = PythonTuple.MakeTuple(pyType, pyException, null);
break;
case Debugging.TraceEventKind.FrameExit:
traceEvent = "return";
args = payload;
break;
}
bool traceDispatchThrew = true;
InTraceBack = true;
try {
TracebackDelegate dlg = traceDispatch(pyFrame, traceEvent, args);
traceDispatchThrew = false;
pyFrame.Setf_trace(dlg);
} finally {
InTraceBack = false;
if (traceDispatchThrew)
{
// We're matching CPython's behavior here. If the trace dispatch throws any exceptions
// we don't re-enable tracebacks. We need to leave the trace callback in place though
// so that we can pop our frames.
_globalTraceObject = _globalTraceDispatch = null;
_exceptionThrown = true;
}
}
}
internal static Exception MakeError(CodeContext context, params object[] args) => PythonExceptions.CreateThrowable(ZipImportError(context), args);
public static string ParseString(char[] text, int start, int length, bool isRaw, bool isUniEscape, bool normalizeLineEndings)
{
Debug.Assert(text != null);
if (isRaw && !isUniEscape && !normalizeLineEndings)
{
return(new String(text, start, length));
}
StringBuilder buf = null;
int i = start;
int l = start + length;
int val;
while (i < l)
{
char ch = text[i++];
if ((!isRaw || isUniEscape) && ch == '\\')
{
if (buf == null)
{
buf = new StringBuilder(length);
buf.Append(text, start, i - start - 1);
}
if (i >= l)
{
if (isRaw)
{
buf.Append('\\');
break;
}
else
{
throw PythonOps.ValueError("Trailing \\ in string");
}
}
ch = text[i++];
if (ch == 'u' || ch == 'U')
{
int len = (ch == 'u') ? 4 : 8;
int max = 16;
if (isUniEscape)
{
if (TryParseInt(text, i, len, max, out val))
{
if (val < 0 || val > 0x10ffff)
{
throw PythonExceptions.CreateThrowable(PythonExceptions.UnicodeDecodeError, isRaw ? "rawunicodeescape" : "unicodeescape", Bytes.Empty, i - start - 2, i - start + len - 1, "illegal Unicode character");
}
if (val < 0x010000)
{
buf.Append((char)val);
}
else
{
buf.Append(char.ConvertFromUtf32(val));
}
i += len;
}
else
{
throw PythonExceptions.CreateThrowable(PythonExceptions.UnicodeDecodeError, isRaw ? "rawunicodeescape" : "unicodeescape", Bytes.Empty, i - start - 2, i - start - 1, @"truncated \uXXXX escape");
}
}
else
{
buf.Append('\\');
buf.Append(ch);
}
}
else
{
if (isRaw)
{
buf.Append('\\');
buf.Append(ch);
continue;
}
switch (ch)
{
case 'a': buf.Append('\a'); continue;
case 'b': buf.Append('\b'); continue;
case 'f': buf.Append('\f'); continue;
case 'n': buf.Append('\n'); continue;
case 'r': buf.Append('\r'); continue;
case 't': buf.Append('\t'); continue;
case 'v': buf.Append('\v'); continue;
case '\\': buf.Append('\\'); continue;
case '\'': buf.Append('\''); continue;
case '\"': buf.Append('\"'); continue;
case '\r': if (i < l && text[i] == '\n')
{
i++;
}
continue;
case '\n': continue;
case 'N': {
IronPython.Modules.unicodedata.PerformModuleReload(null, null);
if (i < l && text[i] == '{')
{
i++;
StringBuilder namebuf = new StringBuilder();
bool namecomplete = false;
while (i < l)
{
char namech = text[i++];
if (namech != '}')
{
namebuf.Append(namech);
}
else
{
namecomplete = true;
break;
}
}
if (!namecomplete || namebuf.Length == 0)
{
throw PythonExceptions.CreateThrowable(PythonExceptions.UnicodeDecodeError, isRaw ? "rawunicodeescape" : "unicodeescape", Bytes.Empty, i, i, @"malformed \N character escape");
}
try {
string uval = IronPython.Modules.unicodedata.lookup(namebuf.ToString());
buf.Append(uval);
} catch (KeyNotFoundException) {
throw PythonExceptions.CreateThrowable(PythonExceptions.UnicodeDecodeError, isRaw ? "rawunicodeescape" : "unicodeescape", Bytes.Empty, i, i, "unknown Unicode character name");
}
}
else
{
throw PythonExceptions.CreateThrowable(PythonExceptions.UnicodeDecodeError, isRaw ? "rawunicodeescape" : "unicodeescape", Bytes.Empty, i, i, @"malformed \N character escape");
}
}
continue;
case 'x': //hex
if (!TryParseInt(text, i, 2, 16, out val))
{
goto default;
}
buf.Append((char)val);
i += 2;
continue;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7': {
int onechar;
val = ch - '0';
if (i < l && HexValue(text[i], out onechar) && onechar < 8)
{
val = val * 8 + onechar;
i++;
if (i < l && HexValue(text[i], out onechar) && onechar < 8)
{
val = val * 8 + onechar;
i++;
}
}
}
buf.Append((char)val);
continue;
default:
buf.Append("\\");
buf.Append(ch);
continue;
}
}
}
else if (ch == '\r' && normalizeLineEndings)
{
if (buf == null)
{
buf = new StringBuilder(length);
buf.Append(text, start, i - start - 1);
}
// normalize line endings
if (i < text.Length && text[i] == '\n')
{
i++;
}
buf.Append('\n');
}
else
{
buf?.Append(ch);
}
}
if (buf != null)
{
return(buf.ToString());
}
return(new String(text, start, length));
}
private static string DoParseString <T>(T[] data, int start, int length, bool isRaw, bool isUniEscape, bool normalizeLineEndings, ParseStringErrorHandler <T> errorHandler = default) where T : IConvertible
{
Bytes bytesData = null;
StringBuilder buf = null;
int i = start;
int l = start + length;
int val;
while (i < l)
{
char ch = data[i++].ToChar(null);
if ((!isRaw || isUniEscape) && ch == '\\')
{
StringBuilderInit(ref buf, data, start, i - 1, length);
if (i >= l)
{
if (isRaw)
{
buf.Append('\\');
}
else
{
handleError(i - start - 1, i - start, "\\ at end of string");
}
break;
}
ch = data[i++].ToChar(null);
if ((ch == 'u' || ch == 'U') && isUniEscape)
{
int len = (ch == 'u') ? 4 : 8;
int max = 16;
if (TryParseInt(data, i, len, max, out val, out int consumed))
{
if (val < 0 || val > 0x10ffff)
{
handleError(i - start - 2, i - start + consumed, isRaw ? @"\Uxxxxxxxx out of range" : "illegal Unicode character");
}
else if (val < 0x010000)
{
buf.Append((char)val);
}
else
{
buf.Append(char.ConvertFromUtf32(val));
}
}
else
{
handleError(i - start - 2, i - start + consumed, ch == 'u' ? @"truncated \uXXXX escape" : @"truncated \UXXXXXXXX escape");
}
i += consumed;
}
else
{
if (isRaw)
{
buf.Append('\\');
buf.Append(ch);
continue;
}
switch (ch)
{
case 'a': buf.Append('\a'); continue;
case 'b': buf.Append('\b'); continue;
case 'f': buf.Append('\f'); continue;
case 'n': buf.Append('\n'); continue;
case 'r': buf.Append('\r'); continue;
case 't': buf.Append('\t'); continue;
case 'v': buf.Append('\v'); continue;
case '\\': buf.Append('\\'); continue;
case '\'': buf.Append('\''); continue;
case '\"': buf.Append('\"'); continue;
case '\n': continue;
case '\r':
if (!normalizeLineEndings)
{
goto default;
}
else if (i < l && data[i].ToChar(null) == '\n')
{
i++;
}
continue;
case 'N': {
IronPython.Modules.unicodedata.PerformModuleReload(null, null);
StringBuilder namebuf = new StringBuilder();
bool namestarted = false;
bool namecomplete = false;
if (i < l && data[i].ToChar(null) == '{')
{
namestarted = true;
i++;
while (i < l)
{
char namech = data[i++].ToChar(null);
if (namech != '}')
{
namebuf.Append(namech);
}
else
{
namecomplete = true;
break;
}
}
}
if (!namecomplete || namebuf.Length == 0)
{
handleError(i - start - 2 - (namestarted ? 1 : 0) - namebuf.Length - (namecomplete ? 1 : 0), // 2 for \N and 1 for { and 1 for }
i - start - (namecomplete ? 1 : 0), // 1 for }
@"malformed \N character escape");
if (namecomplete)
{
buf.Append('}');
}
}
else
{
try {
string uval = IronPython.Modules.unicodedata.lookup(namebuf.ToString());
buf.Append(uval);
} catch (KeyNotFoundException) {
handleError(i - start - 4 - namebuf.Length, // 4 for \N{}
i - start,
"unknown Unicode character name");
}
}
}
continue;
case 'x': //hex
if (!TryParseInt(data, i, 2, 16, out val, out int consumed))
{
handleError(i - start - 2, i - start + consumed, @"truncated \xXX escape");
}
else
{
buf.Append((char)val);
}
i += consumed;
continue;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7': {
val = ch - '0';
if (i < l && HexValue(data[i].ToChar(null), out int onechar) && onechar < 8)
{
val = val * 8 + onechar;
i++;
if (i < l && HexValue(data[i].ToChar(null), out onechar) && onechar < 8)
{
val = val * 8 + onechar;
i++;
}
}
}
buf.Append((char)val);
continue;
default:
buf.Append("\\");
buf.Append(ch);
continue;
}
}
}
else if (ch == '\r' && normalizeLineEndings)
{
StringBuilderInit(ref buf, data, start, i - 1, length);
// normalize line endings
if (i < l && data[i].ToChar(null) == '\n')
{
i++;
}
buf.Append('\n');
}
else
{
buf?.Append(ch);
}
}
return(buf?.ToString());
void handleError(int start, int end, string reason)
{
if (bytesData == null)
{
var ba = data as byte[];
if (ba == null)
{
throw new NotImplementedException("Error handler for non byte[] data not supported");
}
bytesData = new Bytes(ba);
}
if (errorHandler == null)
{
throw PythonExceptions.CreateThrowable(PythonExceptions.UnicodeDecodeError, isRaw ? "rawunicodeescape" : "unicodeescape", bytesData, start, end, reason);
}
var substitute = errorHandler(data, start, end);
if (substitute != null)
{
buf.Append(substitute.ToArray());
}
}
}