git/typthon
1
0
Fork 0
mirror of https://github.com/johndoe6345789/typthon.git synced 2026-04-24 13:45:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename Py_ to Ty_ throughout C API

Browse Source 
Massive automated renaming of all Py_/PyObject/etc. prefixes to Ty_/TyObject/etc.
This includes:
- All public API types (TyObject, TyTypeObject, etc.)
- All public API functions (Ty_Initialize, Ty_BuildValue, etc.)
- All internal API (_Ty_ prefixes)
- Reference counting macros (Ty_INCREF, Ty_DECREF, etc.)
- Type flags (Ty_TPFLAGS_*)
- Debug flags (Ty_DEBUG, Ty_TRACE_REFS, etc.)
- All object type APIs (TyList_, TyDict_, TyUnicode_, etc.)

This changes over 60,000 occurrences across 1000+ files.

Co-authored-by: johndoe6345789 <224850594+johndoe6345789@users.noreply.github.com>
This commit is contained in:
copilot-swe-agent[bot]
2025-12-29 17:37:49 +00:00
parent d812cb400e
commit b198f511d2
1034 changed files with 157370 additions and 157370 deletions
Download Patch File Download Diff File Expand all files Collapse all files

214
Python/Python-tokenize.c
View File

@@ -1,24 +1,24 @@
#include "Python.h"
#include "errcode.h"
#include "internal/pycore_critical_section.h" // Py_BEGIN_CRITICAL_SECTION
#include "internal/pycore_critical_section.h" // Ty_BEGIN_CRITICAL_SECTION
#include "../Parser/lexer/state.h"
#include "../Parser/lexer/lexer.h"
#include "../Parser/tokenizer/tokenizer.h"
#include "../Parser/pegen.h" // _PyPegen_byte_offset_to_character_offset()
#include "../Parser/pegen.h" // _TyPegen_byte_offset_to_character_offset()
static struct PyModuleDef _tokenizemodule;
static struct TyModuleDef _tokenizemodule;
typedef struct {
PyTypeObject *TokenizerIter;
TyTypeObject *TokenizerIter;
} tokenize_state;
static tokenize_state *
get_tokenize_state(PyObject *module) {
return (tokenize_state *)PyModule_GetState(module);
get_tokenize_state(TyObject *module) {
return (tokenize_state *)TyModule_GetState(module);
}
#define _tokenize_get_state_by_type(type) \
get_tokenize_state(PyType_GetModuleByDef(type, &_tokenizemodule))
get_tokenize_state(TyType_GetModuleByDef(type, &_tokenizemodule))
#include "pycore_runtime.h"
#include "clinic/Python-tokenize.c.h"
@@ -35,10 +35,10 @@ typedef struct
int done;
/* Needed to cache line for performance */
PyObject *last_line;
Py_ssize_t last_lineno;
Py_ssize_t last_end_lineno;
Py_ssize_t byte_col_offset_diff;
TyObject *last_line;
Ty_ssize_t last_lineno;
Ty_ssize_t last_end_lineno;
Ty_ssize_t byte_col_offset_diff;
} tokenizeriterobject;
/*[clinic input]
@@ -52,8 +52,8 @@ _tokenizer.tokenizeriter.__new__ as tokenizeriter_new
encoding: str(c_default="NULL") = 'utf-8'
[clinic start generated code]*/
static PyObject *
tokenizeriter_new_impl(PyTypeObject *type, PyObject *readline,
static TyObject *
tokenizeriter_new_impl(TyTypeObject *type, TyObject *readline,
int extra_tokens, const char *encoding)
/*[clinic end generated code: output=7501a1211683ce16 input=f7dddf8a613ae8bd]*/
{
@@ -61,13 +61,13 @@ tokenizeriter_new_impl(PyTypeObject *type, PyObject *readline,
if (self == NULL) {
return NULL;
}
PyObject *filename = PyUnicode_FromString("<string>");
TyObject *filename = TyUnicode_FromString("<string>");
if (filename == NULL) {
return NULL;
}
self->tok = _PyTokenizer_FromReadline(readline, encoding, 1, 1);
if (self->tok == NULL) {
Py_DECREF(filename);
Ty_DECREF(filename);
return NULL;
}
self->tok->filename = filename;
@@ -81,47 +81,47 @@ tokenizeriter_new_impl(PyTypeObject *type, PyObject *readline,
self->last_lineno = 0;
self->last_end_lineno = 0;
return (PyObject *)self;
return (TyObject *)self;
}
static int
_tokenizer_error(tokenizeriterobject *it)
{
_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(it);
if (PyErr_Occurred()) {
_Ty_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(it);
if (TyErr_Occurred()) {
return -1;
}
const char *msg = NULL;
PyObject* errtype = PyExc_SyntaxError;
TyObject* errtype = TyExc_SyntaxError;
struct tok_state *tok = it->tok;
switch (tok->done) {
case E_TOKEN:
msg = "invalid token";
break;
case E_EOF:
PyErr_SetString(PyExc_SyntaxError, "unexpected EOF in multi-line statement");
PyErr_SyntaxLocationObject(tok->filename, tok->lineno,
TyErr_SetString(TyExc_SyntaxError, "unexpected EOF in multi-line statement");
TyErr_SyntaxLocationObject(tok->filename, tok->lineno,
tok->inp - tok->buf < 0 ? 0 : (int)(tok->inp - tok->buf));
return -1;
case E_DEDENT:
msg = "unindent does not match any outer indentation level";
errtype = PyExc_IndentationError;
errtype = TyExc_IndentationError;
break;
case E_INTR:
if (!PyErr_Occurred()) {
PyErr_SetNone(PyExc_KeyboardInterrupt);
if (!TyErr_Occurred()) {
TyErr_SetNone(TyExc_KeyboardInterrupt);
}
return -1;
case E_NOMEM:
PyErr_NoMemory();
TyErr_NoMemory();
return -1;
case E_TABSPACE:
errtype = PyExc_TabError;
errtype = TyExc_TabError;
msg = "inconsistent use of tabs and spaces in indentation";
break;
case E_TOODEEP:
errtype = PyExc_IndentationError;
errtype = TyExc_IndentationError;
msg = "too many levels of indentation";
break;
case E_LINECONT: {
@@ -132,65 +132,65 @@ _tokenizer_error(tokenizeriterobject *it)
msg = "unknown tokenization error";
}
PyObject* errstr = NULL;
PyObject* error_line = NULL;
PyObject* tmp = NULL;
PyObject* value = NULL;
TyObject* errstr = NULL;
TyObject* error_line = NULL;
TyObject* tmp = NULL;
TyObject* value = NULL;
int result = 0;
Py_ssize_t size = tok->inp - tok->buf;
Ty_ssize_t size = tok->inp - tok->buf;
assert(tok->buf[size-1] == '\n');
size -= 1; // Remove the newline character from the end of the line
error_line = PyUnicode_DecodeUTF8(tok->buf, size, "replace");
error_line = TyUnicode_DecodeUTF8(tok->buf, size, "replace");
if (!error_line) {
result = -1;
goto exit;
}
Py_ssize_t offset = _PyPegen_byte_offset_to_character_offset(error_line, tok->inp - tok->buf);
Ty_ssize_t offset = _TyPegen_byte_offset_to_character_offset(error_line, tok->inp - tok->buf);
if (offset == -1) {
result = -1;
goto exit;
}
tmp = Py_BuildValue("(OnnOOO)", tok->filename, tok->lineno, offset, error_line, Py_None, Py_None);
tmp = Ty_BuildValue("(OnnOOO)", tok->filename, tok->lineno, offset, error_line, Ty_None, Ty_None);
if (!tmp) {
result = -1;
goto exit;
}
errstr = PyUnicode_FromString(msg);
errstr = TyUnicode_FromString(msg);
if (!errstr) {
result = -1;
goto exit;
}
value = PyTuple_Pack(2, errstr, tmp);
value = TyTuple_Pack(2, errstr, tmp);
if (!value) {
result = -1;
goto exit;
}
PyErr_SetObject(errtype, value);
TyErr_SetObject(errtype, value);
exit:
Py_XDECREF(errstr);
Py_XDECREF(error_line);
Py_XDECREF(tmp);
Py_XDECREF(value);
Ty_XDECREF(errstr);
Ty_XDECREF(error_line);
Ty_XDECREF(tmp);
Ty_XDECREF(value);
return result;
}
static PyObject *
_get_current_line(tokenizeriterobject *it, const char *line_start, Py_ssize_t size,
static TyObject *
_get_current_line(tokenizeriterobject *it, const char *line_start, Ty_ssize_t size,
int *line_changed)
{
_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(it);
PyObject *line;
_Ty_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(it);
TyObject *line;
if (it->tok->lineno != it->last_lineno) {
// Line has changed since last token, so we fetch the new line and cache it
// in the iter object.
Py_XDECREF(it->last_line);
line = PyUnicode_DecodeUTF8(line_start, size, "replace");
Ty_XDECREF(it->last_line);
line = TyUnicode_DecodeUTF8(line_start, size, "replace");
it->last_line = line;
it->byte_col_offset_diff = 0;
}
@@ -203,15 +203,15 @@ _get_current_line(tokenizeriterobject *it, const char *line_start, Py_ssize_t si
static void
_get_col_offsets(tokenizeriterobject *it, struct token token, const char *line_start,
PyObject *line, int line_changed, Py_ssize_t lineno, Py_ssize_t end_lineno,
Py_ssize_t *col_offset, Py_ssize_t *end_col_offset)
TyObject *line, int line_changed, Ty_ssize_t lineno, Ty_ssize_t end_lineno,
Ty_ssize_t *col_offset, Ty_ssize_t *end_col_offset)
{
_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(it);
Py_ssize_t byte_offset = -1;
_Ty_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(it);
Ty_ssize_t byte_offset = -1;
if (token.start != NULL && token.start >= line_start) {
byte_offset = token.start - line_start;
if (line_changed) {
*col_offset = _PyPegen_byte_offset_to_character_offset_line(line, 0, byte_offset);
*col_offset = _TyPegen_byte_offset_to_character_offset_line(line, 0, byte_offset);
it->byte_col_offset_diff = byte_offset - *col_offset;
}
else {
@@ -220,17 +220,17 @@ _get_col_offsets(tokenizeriterobject *it, struct token token, const char *line_s
}
if (token.end != NULL && token.end >= it->tok->line_start) {
Py_ssize_t end_byte_offset = token.end - it->tok->line_start;
Ty_ssize_t end_byte_offset = token.end - it->tok->line_start;
if (lineno == end_lineno) {
// If the whole token is at the same line, we can just use the token.start
// buffer for figuring out the new column offset, since using line is not
// performant for very long lines.
Py_ssize_t token_col_offset = _PyPegen_byte_offset_to_character_offset_line(line, byte_offset, end_byte_offset);
Ty_ssize_t token_col_offset = _TyPegen_byte_offset_to_character_offset_line(line, byte_offset, end_byte_offset);
*end_col_offset = *col_offset + token_col_offset;
it->byte_col_offset_diff += token.end - token.start - token_col_offset;
}
else {
*end_col_offset = _PyPegen_byte_offset_to_character_offset_raw(it->tok->line_start, end_byte_offset);
*end_col_offset = _TyPegen_byte_offset_to_character_offset_raw(it->tok->line_start, end_byte_offset);
it->byte_col_offset_diff += end_byte_offset - *end_col_offset;
}
}
@@ -238,36 +238,36 @@ _get_col_offsets(tokenizeriterobject *it, struct token token, const char *line_s
it->last_end_lineno = end_lineno;
}
static PyObject *
tokenizeriter_next(PyObject *op)
static TyObject *
tokenizeriter_next(TyObject *op)
{
tokenizeriterobject *it = (tokenizeriterobject*)op;
PyObject* result = NULL;
TyObject* result = NULL;
Py_BEGIN_CRITICAL_SECTION(it);
Ty_BEGIN_CRITICAL_SECTION(it);
struct token token;
_PyToken_Init(&token);
int type = _PyTokenizer_Get(it->tok, &token);
if (type == ERRORTOKEN) {
if(!PyErr_Occurred()) {
if(!TyErr_Occurred()) {
_tokenizer_error(it);
assert(PyErr_Occurred());
assert(TyErr_Occurred());
}
goto exit;
}
if (it->done || type == ERRORTOKEN) {
PyErr_SetString(PyExc_StopIteration, "EOF");
TyErr_SetString(TyExc_StopIteration, "EOF");
it->done = 1;
goto exit;
}
PyObject *str = NULL;
TyObject *str = NULL;
if (token.start == NULL || token.end == NULL) {
str = Py_GetConstant(Py_CONSTANT_EMPTY_STR);
str = Ty_GetConstant(Ty_CONSTANT_EMPTY_STR);
}
else {
str = PyUnicode_FromStringAndSize(token.start, token.end - token.start);
str = TyUnicode_FromStringAndSize(token.start, token.end - token.start);
}
if (str == NULL) {
goto exit;
@@ -279,12 +279,12 @@ tokenizeriter_next(PyObject *op)
}
const char *line_start = ISSTRINGLIT(type) ? it->tok->multi_line_start : it->tok->line_start;
PyObject* line = NULL;
TyObject* line = NULL;
int line_changed = 1;
if (it->tok->tok_extra_tokens && is_trailing_token) {
line = Py_GetConstant(Py_CONSTANT_EMPTY_STR);
line = Ty_GetConstant(Ty_CONSTANT_EMPTY_STR);
} else {
Py_ssize_t size = it->tok->inp - line_start;
Ty_ssize_t size = it->tok->inp - line_start;
if (size >= 1 && it->tok->implicit_newline) {
size -= 1;
}
@@ -292,14 +292,14 @@ tokenizeriter_next(PyObject *op)
line = _get_current_line(it, line_start, size, &line_changed);
}
if (line == NULL) {
Py_DECREF(str);
Ty_DECREF(str);
goto exit;
}
Py_ssize_t lineno = ISSTRINGLIT(type) ? it->tok->first_lineno : it->tok->lineno;
Py_ssize_t end_lineno = it->tok->lineno;
Py_ssize_t col_offset = -1;
Py_ssize_t end_col_offset = -1;
Ty_ssize_t lineno = ISSTRINGLIT(type) ? it->tok->first_lineno : it->tok->lineno;
Ty_ssize_t end_lineno = it->tok->lineno;
Ty_ssize_t col_offset = -1;
Ty_ssize_t end_col_offset = -1;
_get_col_offsets(it, token, line_start, line, line_changed,
lineno, end_lineno, &col_offset, &end_col_offset);
@@ -314,120 +314,120 @@ tokenizeriter_next(PyObject *op)
type = OP;
}
else if (type == NEWLINE) {
Py_DECREF(str);
Ty_DECREF(str);
if (!it->tok->implicit_newline) {
if (it->tok->start[0] == '\r') {
str = PyUnicode_FromString("\r\n");
str = TyUnicode_FromString("\r\n");
} else {
str = PyUnicode_FromString("\n");
str = TyUnicode_FromString("\n");
}
}
end_col_offset++;
}
else if (type == NL) {
if (it->tok->implicit_newline) {
Py_DECREF(str);
str = Py_GetConstant(Py_CONSTANT_EMPTY_STR);
Ty_DECREF(str);
str = Ty_GetConstant(Ty_CONSTANT_EMPTY_STR);
}
}
if (str == NULL) {
Py_DECREF(line);
Ty_DECREF(line);
goto exit;
}
}
result = Py_BuildValue("(iN(nn)(nn)O)", type, str, lineno, col_offset, end_lineno, end_col_offset, line);
result = Ty_BuildValue("(iN(nn)(nn)O)", type, str, lineno, col_offset, end_lineno, end_col_offset, line);
exit:
_PyToken_Free(&token);
if (type == ENDMARKER) {
it->done = 1;
}
Py_END_CRITICAL_SECTION();
Ty_END_CRITICAL_SECTION();
return result;
}
static void
tokenizeriter_dealloc(PyObject *op)
tokenizeriter_dealloc(TyObject *op)
{
tokenizeriterobject *it = (tokenizeriterobject*)op;
PyTypeObject *tp = Py_TYPE(it);
Py_XDECREF(it->last_line);
TyTypeObject *tp = Ty_TYPE(it);
Ty_XDECREF(it->last_line);
_PyTokenizer_Free(it->tok);
tp->tp_free(it);
Py_DECREF(tp);
Ty_DECREF(tp);
}
static PyType_Slot tokenizeriter_slots[] = {
{Py_tp_new, tokenizeriter_new},
{Py_tp_dealloc, tokenizeriter_dealloc},
{Py_tp_getattro, PyObject_GenericGetAttr},
{Py_tp_iter, PyObject_SelfIter},
{Py_tp_iternext, tokenizeriter_next},
static TyType_Slot tokenizeriter_slots[] = {
{Ty_tp_new, tokenizeriter_new},
{Ty_tp_dealloc, tokenizeriter_dealloc},
{Ty_tp_getattro, PyObject_GenericGetAttr},
{Ty_tp_iter, PyObject_SelfIter},
{Ty_tp_iternext, tokenizeriter_next},
{0, NULL},
};
static PyType_Spec tokenizeriter_spec = {
static TyType_Spec tokenizeriter_spec = {
.name = "_tokenize.TokenizerIter",
.basicsize = sizeof(tokenizeriterobject),
.flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_IMMUTABLETYPE),
.flags = (Ty_TPFLAGS_DEFAULT | Ty_TPFLAGS_IMMUTABLETYPE),
.slots = tokenizeriter_slots,
};
static int
tokenizemodule_exec(PyObject *m)
tokenizemodule_exec(TyObject *m)
{
tokenize_state *state = get_tokenize_state(m);
if (state == NULL) {
return -1;
}
state->TokenizerIter = (PyTypeObject *)PyType_FromModuleAndSpec(m, &tokenizeriter_spec, NULL);
state->TokenizerIter = (TyTypeObject *)TyType_FromModuleAndSpec(m, &tokenizeriter_spec, NULL);
if (state->TokenizerIter == NULL) {
return -1;
}
if (PyModule_AddType(m, state->TokenizerIter) < 0) {
if (TyModule_AddType(m, state->TokenizerIter) < 0) {
return -1;
}
return 0;
}
static PyMethodDef tokenize_methods[] = {
static TyMethodDef tokenize_methods[] = {
{NULL, NULL, 0, NULL} /* Sentinel */
};
static PyModuleDef_Slot tokenizemodule_slots[] = {
{Py_mod_exec, tokenizemodule_exec},
{Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED},
{Py_mod_gil, Py_MOD_GIL_NOT_USED},
{Ty_mod_exec, tokenizemodule_exec},
{Ty_mod_multiple_interpreters, Ty_MOD_PER_INTERPRETER_GIL_SUPPORTED},
{Ty_mod_gil, Ty_MOD_GIL_NOT_USED},
{0, NULL}
};
static int
tokenizemodule_traverse(PyObject *m, visitproc visit, void *arg)
tokenizemodule_traverse(TyObject *m, visitproc visit, void *arg)
{
tokenize_state *state = get_tokenize_state(m);
Py_VISIT(state->TokenizerIter);
Ty_VISIT(state->TokenizerIter);
return 0;
}
static int
tokenizemodule_clear(PyObject *m)
tokenizemodule_clear(TyObject *m)
{
tokenize_state *state = get_tokenize_state(m);
Py_CLEAR(state->TokenizerIter);
Ty_CLEAR(state->TokenizerIter);
return 0;
}
static void
tokenizemodule_free(void *m)
{
tokenizemodule_clear((PyObject *)m);
tokenizemodule_clear((TyObject *)m);
}
static struct PyModuleDef _tokenizemodule = {
static struct TyModuleDef _tokenizemodule = {
PyModuleDef_HEAD_INIT,
.m_name = "_tokenize",
.m_size = sizeof(tokenize_state),