Enum CudaStmt 

pub enum CudaStmt {
    VarDecl {
        ty: CudaType,
        name: String,
        init: Option<CudaExpr>,
    },
    Assign {
        lhs: CudaExpr,
        rhs: CudaExpr,
    },
    CompoundAssign {
        lhs: CudaExpr,
        op: CudaBinOp,
        rhs: CudaExpr,
    },
    IfElse {
        cond: CudaExpr,
        then_body: Vec<CudaStmt>,
        else_body: Option<Vec<CudaStmt>>,
    },
    ForLoop {
        init: Box<CudaStmt>,
        cond: CudaExpr,
        step: CudaExpr,
        body: Vec<CudaStmt>,
    },
    WhileLoop {
        cond: CudaExpr,
        body: Vec<CudaStmt>,
    },
    KernelLaunch {
        name: String,
        config: LaunchConfig,
        args: Vec<CudaExpr>,
    },
    CudaMalloc {
        ptr: String,
        size: CudaExpr,
    },
    CudaMemcpy {
        dst: CudaExpr,
        src: CudaExpr,
        size: CudaExpr,
        kind: MemcpyKind,
    },
    CudaFree(CudaExpr),
    Return(Option<CudaExpr>),
    Expr(CudaExpr),
    DeviceSync,
    CheckError(CudaExpr),
    Block(Vec<CudaStmt>),
    Break,
    Continue,
}

CUDA statement AST node.

Variants

VarDecl

Variable declaration with optional initializer: CudaType name [ = init ];

Fields

ty: CudaType

name: String

init: Option<CudaExpr>

Assign

Simple assignment: lhs = rhs;

Fields

lhs: CudaExpr

rhs: CudaExpr

CompoundAssign

Compound assignment: lhs += rhs; etc.

Fields

lhs: CudaExpr

op: CudaBinOp

rhs: CudaExpr

IfElse

If / optional else:

Fields

cond: CudaExpr

then_body: Vec<CudaStmt>

else_body: Option<Vec<CudaStmt>>

ForLoop

C-style for loop: for (init; cond; step) { body }

Fields

init: Box<CudaStmt>

cond: CudaExpr

step: CudaExpr

body: Vec<CudaStmt>

WhileLoop

While loop: while (cond) { body }

Fields

cond: CudaExpr

body: Vec<CudaStmt>

KernelLaunch

CUDA kernel launch: name<<<grid, block, shmem, stream>>>(args...);

Fields

name: String

config: LaunchConfig

args: Vec<CudaExpr>

CudaMalloc

cudaMalloc((void**)&ptr, size);

Fields

ptr: String

size: CudaExpr

CudaMemcpy

cudaMemcpy(dst, src, size, kind);

Fields

dst: CudaExpr

src: CudaExpr

size: CudaExpr

kind: MemcpyKind

CudaFree(CudaExpr)

cudaFree(ptr);

Return(Option<CudaExpr>)

return expr;

Expr(CudaExpr)

Raw expression statement: expr;

DeviceSync

cudaDeviceSynchronize();

CheckError(CudaExpr)

cudaCheckError() macro invocation

Block(Vec<CudaStmt>)

Block of statements grouped with {}

Break

break;

Continue

continue;

Trait Implementations

impl Clone for CudaStmt

fn clone(&self) -> CudaStmt

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CudaStmt

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for CudaStmt

fn eq(&self, other: &CudaStmt) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for CudaStmt