Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

improved documentation for build_int_mul, build_int_sub, build_float_sub and build_float_mul #535

Open
wants to merge 9 commits into
base: master
Choose a base branch
from
Open

improved documentation for build_int_mul, build_int_sub, build_float_sub and build_float_mul #535

Changes from all commits
Commits
Show all changes
9 commits
Select commit Hold shift + click to select a range
e99657c
improved documentation for build_int_mul, build_int_sub, build_float_…
OranGot Sep 16, 2024
80e5c69
capitalized C in creates and fixed spacing after the slashes
OranGot Sep 20, 2024
b940135
Fixed spacing
TheDan64 Oct 10, 2024
ba684e2
Fixed spacing
TheDan64 Oct 10, 2024
49b80b1
Update builder.rs
TheDan64 Oct 10, 2024
8d11cc9
Merge branch 'master' into master
TheDan64 Oct 10, 2024
c48900f
Fixed typos
TheDan64 Oct 10, 2024
2303c58
Merge branch 'master' into master
TheDan64 Oct 10, 2024
3ef4e07
Typo
TheDan64 Oct 10, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
126 changes: 122 additions & 4 deletions src/builder.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2530,7 +2530,36 @@ impl<'ctx> Builder<'ctx> {

unsafe { Ok(T::new(value)) }
}

/// Creates integer subtraction given `lhs` and `rhs`. It returns either an `IntValue` or `BuilderError`
/// ```rust,no_run
/// fn int_subtraction(lhs: i8, rhs: i8) -> i8 {
/// lhs-rhs
/// }
/// ```
/// # Example in inkwell:
/// The rust code above demonstrates how the example below could have been written if it was rust:
/// ```rust,no_run
/// use inkwell::context::Context;
///
/// // Setup
/// let context = Context::create();
/// let module = context.create_module("my_module");
/// let builder = context.create_builder();
/// let i8_type = context.i8_type();
/// let fn_type = i8_type.fn_type(&[i8_type.into(), i8_type.into()], false);
///
/// // Function Definition
/// let function = module.add_function("int_subtraction", fn_type, None);
/// let value1 = function.get_first_param().unwrap().into_int_value();
/// let value2 = function.get_nth_param(1).unwrap().into_int_value();
/// let entry_block = context.append_basic_block(function, "entry");
///
/// builder.position_at_end(entry_block);
///
/// let sub = builder.build_int_sub(value1, value2, "int_subtract").unwrap();
///
/// builder.build_return(Some(&sub)).unwrap();
/// ```
// SubType: <I>(&self, lhs: &IntValue<I>, rhs: &IntValue<I>, name: &str) -> IntValue<I> {
pub fn build_int_sub<T: IntMathValue<'ctx>>(&self, lhs: T, rhs: T, name: &str) -> Result<T, BuilderError> {
if self.positioned.get() != PositionState::Set {
Expand Down Expand Up @@ -2564,7 +2593,36 @@ impl<'ctx> Builder<'ctx> {

unsafe { Ok(T::new(value)) }
}

/// Creates float subtraction given `lhs` and `rhs` as FloatValue. It returns either an `FloatValue` or `BuilderError`
/// ```rust,no_run
/// fn float_subtraction(lhs: f16, rhs: f16) -> f16 {
/// lhs-rhs
/// }
/// ```
/// # Example in inkwell:
/// The rust code above demonstrates how the example below could have been written if it was rust:
/// ```rust,no_run
/// use inkwell::context::Context;
///
/// // Setup
/// let context = Context::create();
/// let module = context.create_module("my_module");
/// let builder = context.create_builder();
/// let f16_type = context.f16_type();
/// let fn_type = f16_type.fn_type(&[f16_type.into(), f16_type.into()], false);
///
/// // Function Definition
/// let function = module.add_function("float_subtraction", fn_type, None);
/// let value1 = function.get_first_param().unwrap().into_float_value();
/// let value2 = function.get_nth_param(1).unwrap().into_float_value();
/// let entry_block = context.append_basic_block(function, "entry");
///
/// builder.position_at_end(entry_block);
///
/// let sub = builder.build_float_sub(value1, value2, "float_subtract").unwrap();
///
/// builder.build_return(Some(&sub)).unwrap();
/// ```
// SubType: <F>(&self, lhs: &FloatValue<F>, rhs: &FloatValue<F>, name: &str) -> FloatValue<F> {
pub fn build_float_sub<T: FloatMathValue<'ctx>>(&self, lhs: T, rhs: T, name: &str) -> Result<T, BuilderError> {
if self.positioned.get() != PositionState::Set {
Expand All @@ -2575,7 +2633,37 @@ impl<'ctx> Builder<'ctx> {

unsafe { Ok(T::new(value)) }
}

/// Creates int multiplication given `lhs` and `rhs` as IntValue. It returns either an
/// `IntValue` or `BuilderError`
/// ```rust,no_run
/// fn int_mul(lhs: i8, rhs: i8) -> i8 {
/// lhs*rhs
/// }
/// ```
/// # Example in inkwell:
/// The rust code above demonstrates how the example below could have been written if it was rust:
/// ```rust,no_run
/// use inkwell::context::Context;
///
/// // Setup
/// let context = Context::create();
/// let module = context.create_module("my_module");
/// let builder = context.create_builder();
/// let i8_type = context.i8_type();
/// let fn_type = i8_type.fn_type(&[i8_type.into(), i8_type.into()], false);
///
/// // Function Definition
/// let function = module.add_function("float_subtraction", fn_type, None);
/// let value1 = function.get_first_param().unwrap().into_int_value();
/// let value2 = function.get_nth_param(1).unwrap().into_int_value();
/// let entry_block = context.append_basic_block(function, "entry");
///
/// builder.position_at_end(entry_block);
///
/// let mul = builder.build_int_mul(value1, value2, "int_multiplication").unwrap();
///
/// builder.build_return(Some(&mul)).unwrap();
/// ```
// SubType: <I>(&self, lhs: &IntValue<I>, rhs: &IntValue<I>, name: &str) -> IntValue<I> {
pub fn build_int_mul<T: IntMathValue<'ctx>>(&self, lhs: T, rhs: T, name: &str) -> Result<T, BuilderError> {
if self.positioned.get() != PositionState::Set {
Expand Down Expand Up @@ -2610,7 +2698,37 @@ impl<'ctx> Builder<'ctx> {

unsafe { Ok(T::new(value)) }
}

/// Creates float multiplication
/// given `lhs` and `rhs` as FloatValue. It returns either an `FloatValue` or `BuilderError`
/// ```rust,no_run
/// fn float_subtraction(lhs: f16, rhs: f16) -> f16 {
/// lhs*rhs
/// }
/// ```
/// # Example in inkwell:
/// The rust code above demonstrates how the example below could have been written if it was rust:
/// ```rust,no_run
/// use inkwell::context::Context;
///
/// // Setup
/// let context = Context::create();
/// let module = context.create_module("my_module");
/// let builder = context.create_builder();
/// let f16_type = context.f16_type();
/// let fn_type = f16_type.fn_type(&[f16_type.into(), f16_type.into()], false);
///
/// // Function Definition
/// let function = module.add_function("float_subtraction", fn_type, None);
/// let value1 = function.get_first_param().unwrap().into_float_value();
/// let value2 = function.get_nth_param(1).unwrap().into_float_value();
/// let entry_block = context.append_basic_block(function, "entry");
///
/// builder.position_at_end(entry_block);
///
/// let sub = builder.build_float_mul(value1, value2, "float_mul").unwrap();
///
/// builder.build_return(Some(&sub)).unwrap();
/// ```
// SubType: <F>(&self, lhs: &FloatValue<F>, rhs: &FloatValue<F>, name: &str) -> FloatValue<F> {
pub fn build_float_mul<T: FloatMathValue<'ctx>>(&self, lhs: T, rhs: T, name: &str) -> Result<T, BuilderError> {
if self.positioned.get() != PositionState::Set {
Expand Down
Loading