1. Added example "easy_use"

2. Improved example "easy"
3. IMproved docs

Author: denisandroid

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "clucstr"
-version = "1.1.8"
-authors = ["Денис Котляров <#Ulin Project 18, denis2005991@gmail.com>"]
+version = "1.1.9"
+authors = ["Denis Kotlyarov (Денис Котляров) <denis2005991@gmail.com>"]
 repository = "https://github.com/clucompany/cluCStr.git"
 edition = "2018"
 

README.md

@@ -4,7 +4,7 @@
 [![crates.io](http://meritbadge.herokuapp.com/clucstr)](https://crates.io/crates/clucstr)
 [![Documentation](https://docs.rs/clucstr/badge.svg)](https://docs.rs/clucstr)
 
-Safe creation of 'CStr' with zero cost at a compilation stage with check of zero bytes and a possibility of communication of several values.
+Safe creation of “CStr” with zero cost at the compilation stage with checking for zero bytes and the ability to transfer multiple values.
 
 # Features
 1. Creation of safe CStr at a compilation stage.
@@ -14,50 +14,56 @@ Safe creation of 'CStr' with zero cost at a compilation stage with check of zero
 
 # Use
 ```
+
 #![feature(plugin)]
 #![plugin(clucstr)]
 
 use std::ffi::CStr;
 
 fn main() {
-	let c_str = cstr!("cluWorld");
-	//"cluWorld" <-- [99, 108, 117, 87, 111, 114, 108, 100, 0], len:9
+	let cstr_1 = cstr!("cluWorld");
+	assert_eq!(cstr_1.to_bytes_with_nul(), b"cluWorld\0");
+	//"cluWorld", [99, 108, 117, 87, 111, 114, 108, 100, 0], len:9
 	
-	let c_str2 = cstr!("cluWorld\0");
-	//"cluWorld" <-- [99, 108, 117, 87, 111, 114, 108, 100, 0], len:9
+	let cstr_2 = cstr!("cluWorld\0");
+	//"cluWorld", [99, 108, 117, 87, 111, 114, 108, 100, 0], len:9
+	assert_eq!(cstr_2.to_bytes_with_nul(), b"cluWorld\0");
 	
-	let c_str3 = cstr!("clu", b"World");
-	//"cluWorld" <-- [99, 108, 117, 87, 111, 114, 108, 100, 0], len:9
+	let cstr_3 = cstr!("clu", b"World");
+	//"cluWorld", [99, 108, 117, 87, 111, 114, 108, 100, 0], len:9
+	assert_eq!(cstr_3.to_bytes_with_nul(), b"cluWorld\0");
 	
-	let c_str4 = cstr!(
+	let cstr_4 = cstr!(
 		b'c', b'l', b'u',
 		b'W', b'o', b'r', b'l', b'd',
 		0
 	);
-	//"cluWorld" <-- [99, 108, 117, 87, 111, 114, 108, 100, 0], len:9
+	//"cluWorld", [99, 108, 117, 87, 111, 114, 108, 100, 0], len:9
+	assert_eq!(cstr_4.to_bytes_with_nul(), b"cluWorld\0");
 	
-	let c_str5 = cstr!(
+	let cstr_5 = cstr!(
 		"clu",
 		//It is possible to insert such values as: [u8], & 'static str, u8, i8, (0 without specifying the type).
 		
 		b'W', b'o', b'r', b'l', b"d\0"
 		//The zero byte is automatically added, it is possible to write it, and it is possible not to write.
 		//It is forbidden to insert zero byte in the middle or at the beginning of a line.
 	);
-	//"cluWorld" <-- [99, 108, 117, 87, 111, 114, 108, 100, 0], len:9
+	//"cluWorld", [99, 108, 117, 87, 111, 114, 108, 100, 0], len:9
+	assert_eq!(cstr_5.to_bytes_with_nul(), b"cluWorld\0");
 	
-	my_function(c_str);
-	my_function(c_str2);
-	my_function(c_str3);
-	my_function(c_str4);
-	my_function(c_str5);
+	my_function(1, cstr_1);
+	my_function(2, cstr_2);
+	my_function(3, cstr_3);
+	my_function(4, cstr_4);
+	my_function(5, cstr_5);
 }
 
-fn my_function(a:  &'static CStr) {
+fn my_function(num: usize, a: &'static CStr) {
 	//'static --> it is possible not to write.
 	
 	let c_arr = a.to_bytes_with_nul();
-	println!("{:?} <-- array: {:?}, len: {}", a, c_arr, c_arr.len());
+	println!("#cstr_{} {:?}, array: {:?}, len: {}", num, a, c_arr, c_arr.len());
 }
 ```
 

examples/easy_use.rs

@@ -0,0 +1,14 @@
+
+#![feature(plugin)]
+#![plugin(clucstr)]
+
+use std::ffi::CStr;
+
+fn main() {
+	let cstr = cstr!("My CSTR!");
+	//&CStr
+	
+	assert_eq!(cstr.to_bytes(), b"My CSTR!");
+	assert_eq!(cstr.to_bytes_with_nul(), b"My CSTR!\0");
+}
+

examples/use.rs

@@ -5,42 +5,47 @@
 use std::ffi::CStr;
 
 fn main() {
-	let c_str = cstr!("cluWorld");
-	//"cluWorld" <-- [99, 108, 117, 87, 111, 114, 108, 100, 0], len:9
+	let cstr_1 = cstr!("cluWorld");
+	assert_eq!(cstr_1.to_bytes_with_nul(), b"cluWorld\0");
+	//"cluWorld", [99, 108, 117, 87, 111, 114, 108, 100, 0], len:9
 
-	let c_str2 = cstr!("cluWorld\0");
-	//"cluWorld" <-- [99, 108, 117, 87, 111, 114, 108, 100, 0], len:9
+	let cstr_2 = cstr!("cluWorld\0");
+	//"cluWorld", [99, 108, 117, 87, 111, 114, 108, 100, 0], len:9
+	assert_eq!(cstr_2.to_bytes_with_nul(), b"cluWorld\0");
 
-	let c_str3 = cstr!("clu", b"World");
-	//"cluWorld" <-- [99, 108, 117, 87, 111, 114, 108, 100, 0], len:9
+	let cstr_3 = cstr!("clu", b"World");
+	//"cluWorld", [99, 108, 117, 87, 111, 114, 108, 100, 0], len:9
+	assert_eq!(cstr_3.to_bytes_with_nul(), b"cluWorld\0");
 
-	let c_str4 = cstr!(
+	let cstr_4 = cstr!(
 		b'c', b'l', b'u',
 		b'W', b'o', b'r', b'l', b'd',
 		0
 	);
-	//"cluWorld" <-- [99, 108, 117, 87, 111, 114, 108, 100, 0], len:9
+	//"cluWorld", [99, 108, 117, 87, 111, 114, 108, 100, 0], len:9
+	assert_eq!(cstr_4.to_bytes_with_nul(), b"cluWorld\0");
 
-	let c_str5 = cstr!(
+	let cstr_5 = cstr!(
 		"clu",
 		//It is possible to insert such values as: [u8], & 'static str, u8, i8, (0 without specifying the type).
 
 		b'W', b'o', b'r', b'l', b"d\0"
 		//The zero byte is automatically added, it is possible to write it, and it is possible not to write.
 		//It is forbidden to insert zero byte in the middle or at the beginning of a line.
 	);
-	//"cluWorld" <-- [99, 108, 117, 87, 111, 114, 108, 100, 0], len:9
+	//"cluWorld", [99, 108, 117, 87, 111, 114, 108, 100, 0], len:9
+	assert_eq!(cstr_5.to_bytes_with_nul(), b"cluWorld\0");
 
-	my_function(c_str);
-	my_function(c_str2);
-	my_function(c_str3);
-	my_function(c_str4);
-	my_function(c_str5);
+	my_function(1, cstr_1);
+	my_function(2, cstr_2);
+	my_function(3, cstr_3);
+	my_function(4, cstr_4);
+	my_function(5, cstr_5);
 }
 
-fn my_function(a:  &'static CStr) {
+fn my_function(num: usize, a: &'static CStr) {
 	//'static --> it is possible not to write.
 
 	let c_arr = a.to_bytes_with_nul();
-	println!("{:?} <-- array: {:?}, len: {}", a, c_arr, c_arr.len());
+	println!("#cstr_{} {:?}, array: {:?}, len: {}", num, a, c_arr, c_arr.len());
 }

src/lib.rs

@@ -17,7 +17,7 @@
 //
 
 /*!
-Safe creation of 'CStr' with zero cost at a compilation stage with check of zero bytes and a possibility of communication of several values.
+Safe creation of “CStr” with zero cost at the compilation stage with checking for zero bytes and the ability to transfer multiple values.
 
 # Features
 1. Creation of safe CStr at a compilation stage.
@@ -27,50 +27,56 @@ Safe creation of 'CStr' with zero cost at a compilation stage with check of zero
 
 # Use
 ```
+
 #![feature(plugin)]
 #![plugin(clucstr)]
 
 use std::ffi::CStr;
 
 fn main() {
-	let c_str = cstr!("cluWorld");
-	//"cluWorld" <-- [99, 108, 117, 87, 111, 114, 108, 100, 0], len:9
+	let cstr_1 = cstr!("cluWorld");
+	assert_eq!(cstr_1.to_bytes_with_nul(), b"cluWorld\0");
+	//"cluWorld", [99, 108, 117, 87, 111, 114, 108, 100, 0], len:9
 	
-	let c_str2 = cstr!("cluWorld\0");
-	//"cluWorld" <-- [99, 108, 117, 87, 111, 114, 108, 100, 0], len:9
+	let cstr_2 = cstr!("cluWorld\0");
+	//"cluWorld", [99, 108, 117, 87, 111, 114, 108, 100, 0], len:9
+	assert_eq!(cstr_2.to_bytes_with_nul(), b"cluWorld\0");
 	
-	let c_str3 = cstr!("clu", b"World");
-	//"cluWorld" <-- [99, 108, 117, 87, 111, 114, 108, 100, 0], len:9
+	let cstr_3 = cstr!("clu", b"World");
+	//"cluWorld", [99, 108, 117, 87, 111, 114, 108, 100, 0], len:9
+	assert_eq!(cstr_3.to_bytes_with_nul(), b"cluWorld\0");
 	
-	let c_str4 = cstr!(
+	let cstr_4 = cstr!(
 		b'c', b'l', b'u',
 		b'W', b'o', b'r', b'l', b'd',
 		0
 	);
-	//"cluWorld" <-- [99, 108, 117, 87, 111, 114, 108, 100, 0], len:9
+	//"cluWorld", [99, 108, 117, 87, 111, 114, 108, 100, 0], len:9
+	assert_eq!(cstr_4.to_bytes_with_nul(), b"cluWorld\0");
 	
-	let c_str5 = cstr!(
+	let cstr_5 = cstr!(
 		"clu",
 		//It is possible to insert such values as: [u8], & 'static str, u8, i8, (0 without specifying the type).
 		
 		b'W', b'o', b'r', b'l', b"d\0"
 		//The zero byte is automatically added, it is possible to write it, and it is possible not to write.
 		//It is forbidden to insert zero byte in the middle or at the beginning of a line.
 	);
-	//"cluWorld" <-- [99, 108, 117, 87, 111, 114, 108, 100, 0], len:9
+	//"cluWorld", [99, 108, 117, 87, 111, 114, 108, 100, 0], len:9
+	assert_eq!(cstr_5.to_bytes_with_nul(), b"cluWorld\0");
 	
-	my_function(c_str);
-	my_function(c_str2);
-	my_function(c_str3);
-	my_function(c_str4);
-	my_function(c_str5);
+	my_function(1, cstr_1);
+	my_function(2, cstr_2);
+	my_function(3, cstr_3);
+	my_function(4, cstr_4);
+	my_function(5, cstr_5);
 }
 
-fn my_function(a:  &'static CStr) {
+fn my_function(num: usize, a: &'static CStr) {
 	//'static --> it is possible not to write.
 	
 	let c_arr = a.to_bytes_with_nul();
-	println!("{:?} <-- array: {:?}, len: {}", a, c_arr, c_arr.len());
+	println!("#cstr_{} {:?}, array: {:?}, len: {}", num, a, c_arr, c_arr.len());
 }
 ```
 
@@ -182,7 +188,7 @@ extern crate rustc_plugin;
 mod nightly;
 pub use self::nightly::*;
 
-///Safe creation of 'CStr' at a compilation stage with check on zero bytes and a possibility of concatenation of several values.
+///Safe creation of “CStr” with zero cost at the compilation stage with checking for zero bytes and the ability to transfer multiple values.
 
 //The description only for documentation not to use. 
 //Connect a plug-in! (The plug-in is described in nightly.rs, connect a plug-in as it is specified in documentation)

src/nightly.rs

@@ -67,6 +67,8 @@ pub fn cstr(cx: &mut ExtCtxt, sp: Span, args: &[TokenTree]) -> Box<dyn MacResult
 			match unk.node {
 				ExprKind::Lit(ref l) => {
 					match l.node {
+						
+						//"str"
 						LitKind::Str(ref array, _) => {
 							let s_array = array.as_str();
 							let array = s_array.as_bytes();
@@ -86,6 +88,9 @@ pub fn cstr(cx: &mut ExtCtxt, sp: Span, args: &[TokenTree]) -> Box<dyn MacResult
 								}
 							}
 						},
+						//
+						
+						//b"str"
 						LitKind::ByteStr(ref array) => {
 							let array = array.as_slice();
 
@@ -104,17 +109,22 @@ pub fn cstr(cx: &mut ExtCtxt, sp: Span, args: &[TokenTree]) -> Box<dyn MacResult
 								}
 							}
 						},
+						//
+						
+						
+						
+						
 
+						//Int 0
+						LitKind::Int(0, LitIntType::Unsuffixed) if unk_index+1 == args_len => break 'looper,
 						LitKind::Int(0, LitIntType::Unsuffixed) => {
-							if unk_index+1 == args_len {
-								break 'looper;
-							}else {
-								cx.span_err(l.span, "trailing byte detected");
-								return DummyResult::any(sp);
-							}
+							cx.span_err(l.span, "trailing byte detected");
+							return DummyResult::any(sp);
 						},
+						//
 
-						LitKind::Int(ref a, LitIntType::Unsigned(UintTy::U8)) 
+						//Int, i8, u8
+						LitKind::Int(ref a, LitIntType::Unsigned(UintTy::U8))
 						| LitKind::Int(ref a, LitIntType::Signed(IntTy::I8))
 						=> {
 							match a {
@@ -131,21 +141,21 @@ pub fn cstr(cx: &mut ExtCtxt, sp: Span, args: &[TokenTree]) -> Box<dyn MacResult
 								},
 							}	
 						},
+						//
 
-						LitKind::Byte(ref a) => {
-							match a {
-								0u8 if unk_index+1 == args_len => break 'looper,
-								0u8 => {
-									cx.span_err(l.span, "trailing byte detected");
-									return DummyResult::any(sp);
-								},
-								_ => {
-									r_array.push(
-										cx.expr_lit(sp, LitKind::Int(*a as u128, LitIntType::Unsigned(UintTy::U8)))
-									);
-								},	
-							}
+						//Byte 0:
+						LitKind::Byte(0) if unk_index+1 == args_len => break 'looper,
+						LitKind::Byte(0) => {
+							cx.span_err(l.span, "trailing byte detected");
+							return DummyResult::any(sp);
 						},
+						//
+						
+						//Byte
+						LitKind::Byte(a) => r_array.push(cx.expr_lit(sp, LitKind::Int(a as u128, LitIntType::Unsigned(UintTy::U8)))),
+						//
+						
+						//Unk type
 						_ => {
 							cx.span_err(l.span, "incorrect data, was expected: &[u8], str, u8, i8");
 							return DummyResult::any(sp);
@@ -214,13 +224,11 @@ pub fn cstr(cx: &mut ExtCtxt, sp: Span, args: &[TokenTree]) -> Box<dyn MacResult
 			},
 			id: ast::DUMMY_NODE_ID,
 			rules: BlockCheckMode::Unsafe(UnsafeSource::CompilerGenerated), //<-- UNSAFE
-			span: sp, 
-			
-			//recovered: false,
-			//FIX!, UPDATE RUST:((
+			span: sp,
 		});
 		cx.expr_block(block) //RESULT EXPR
-	})// unsafe { &*([u8] as *const [u8] as *const CStr) }
+	})
+	// unsafe { &*([u8] as *const [u8] as *const CStr) }
 }