Minted 在到达页面末尾时不会拆分代码

Question

我正在尝试为 minted 制作一个自定义模板，其中包含背景颜色、行号、标题等。但是，我在页面结尾时遇到了问题。代码不会拆分到新页面，而是继续并“退出”页面。

\documentclass{article}

\usepackage[skins,minted,breakable]{tcolorbox}

\BeforeBeginEnvironment{minted}{\vspace{0.8em}}
\AfterEndEnvironment{minted}{\vspace{0.8em}}


\definecolor{mintedbackground}{rgb}{0.95,0.95,0.95}
\definecolor{mintedframe}{rgb}{0.52,0.54,0.66}

\setminted{
    fontfamily=tt,
    linenos=true,
    numberblanklines=true,
    numbersep=12pt,
    numbersep=5pt,
    gobble=0,
    frame=leftline,
    framesep=2mm,
    funcnamehighlighting=true,
    tabsize=4,
    obeytabs=false,
    mathescape=false
    samepage=false,
    showspaces=false,
    showtabs =false,
    texcl=false,
    baselinestretch=1.2,
    fontsize=\footnotesize,
    breaklines=true,
}


\renewtcblisting{minted}[3][]{
enhanced,
breakable,% Allow page breaks
listing engine=minted,
listing only,#1, title=#3, minted language=#2,
coltitle=mintedbackground!30!black,
fonttitle=\ttfamily\footnotesize,
sharp corners, top=0mm, bottom=0mm,
title code={\path[draw=mintedframe,dashed, fill=mintedbackground](title.south west)--(title.south east);},
frame code={\path[draw=mintedframe, fill=mintedbackground](frame.south west) rectangle (frame.north east);}
}

\title{Résumé}

\begin{document}



\pagenumbering{arabic} 


\section{Pointeurs}
On appelle Lvalue (left value) tout objet pouvant être placé à gauche d'un opérateur d'affectation. Une Lvalue est caractérisée par :
\begin{itemize}
    \item son adresse, c'est-à-dire l'adresse-mémoire à partir de laquelle l'objet est stocké ;
    \item sa valeur, c'est-à-dire ce qui est stocké à cette adresse.
\end{itemize}


Un pointeur est un objet (Lvalue) dont la valeur est égale à l'adresse d'un autre objet. 

\subsection{Opérations}
La valeur d'un pointeur étant un entier, on peut lui appliquer un certain nombre d'opérateurs arithmétiques classiques. Les seules opérations arithmétiques valides sur les pointeurs sont :
\begin{itemize}
    \item l'addition d'un entier à un pointeur. Le résultat est un pointeur de même type que le pointeur de départ ;
    \item la soustraction d'un entier à un pointeur. Le résultat est un pointeur de même type que le pointeur de départ ;
    \item la différence de deux pointeurs pointant tous deux vers des objets de même type. Le résultat est un entier. 
 \end{itemize}   
\section{Thread}
\subsection{Subsection}
\begin{minted}{c}{kernel.h}
Include stdio.h

enum kernel_states {
    KERNEL_TERMINATED,
    KERNEL_RUNNING,
    KERNEL_READY,
    KERNEL_BLOCKED
 }

struct kernel_context {
    uint32_t regs[15];
    uint32_t psr;
}

struct kernel_tcb {
    struct kernel_context context;
    enum kernel_steates state;
    struct kernel_tcb* t_next;
    struct kernel_tcb* s_next;
    int32_t id;
    char name[32];
    uint32_t stack_size;
    uint32_t stack[] //défini au runtime avec un malloc
}

Extern …
\end{minted}

\#R0 : context of former thread

\#R1 : context of new thread
\begin{minted}{gas}{kernel\_asm.S}
.text
.global kernel_transfer

kernel_transfer:
    nop
    stmia   r0, {r0-r12,sp,lr}
    mrs     r4,cpsr
    str     r4,[r0,#15*4]
    ldr     r4,[r1,#15*4]
    msr     cpsr, r4
    ldmia   r1,{r0-r12,sp,pc]

\end{minted}
\begin{minted}{c}{kernel.c}
extern void kernel_transfer(
    struct kernel_context* former;
    struct kernel_context* new;s
);

static struct kernel_tcb idle_tab = {
    .state = KERNEL_RUNNING;
    .t_next = &idle_task;
    .id = 0;
    .name = "idle";
    .stack_size = 0;
};

static struct kernel_tcb* running_task = &idle_task;
static int32_t task_id = 1;

// Place next task to the list
void kernel_add_tcb(struct kernel_tcb){
    tcb->t_next = idle_task.t_next;
    idle_task.t.next = tcb;
}

struct kernel_tab" kernel_new_tcb(uint32_t stack_size, const char* name){
    struct kernel_tcb* tcb = malloc (sizeof(struct kernel_tab) + stack_size);
    tcb->id = kernel_new_taskid();
    // If cannot allocate space
    if(tcb==0) return 0;
    memset(tcb, 0, sizeof(struct kernel_tab));
    tcb->stack_size = stack.size;
    // Only copy the 32 first char (ignore the next ones)
    strncpy(tab->name, name, sizeof(tcb->name);
    return tcb;
}

int32_t kernel_new_taskid(){
    static int32_t task_id = 0;
    return task_id++;
}

struct kernel_tab kernel_running_task(){
    return running_task;
}
void kernel_yield(){
    struct kernel_tcb* former_task = running_task;
    struct kernel_tcb* new_task = former_task->t_next;
    if(former_task->state == KERNEL_RUNNING) former_task->state = KERNEL_READY;
    while(new_task->state) != KERNEL_READY) new_task = new_task->t_next;
    running_task = new_task;
    new_task->state = KERNEL_RUNNING;
    kernel_transfer(&former_task->context, &new_task->context);
}
\end{minted}
\end{document}