extern crate proc_macro;

use proc_macro::TokenStream;

use syn::{
    parse_macro_input,
    Expr,
    // Cargo.toml 内  syn = {"2.0", features = ["full"] }
    ItemFn, // "full" が必要
};

// 関数を処理する場合 as ItemFn を使用
#[proc_macro]
pub fn tokenstream_analyze_for_function(input: TokenStream) -> TokenStream {

    let inputcopy = input.clone();
    
    let myinput:ItemFn = parse_macro_input!(inputcopy as ItemFn);// トークンストリームを解析

    return input;
}

// 式を処理する場合 as Expr を使用
#[proc_macro]
pub fn tokenstream_analyze_for_formula(input: TokenStream) -> TokenStream {

    let inputcopy = input.clone();

    let myinput:Expr = parse_macro_input!(inputcopy as Expr);// トークンストリームを解析

    return input;
}

extern crate mymacro;

// 関数に対してマクロを適用
mymacro::tokenstream_analyze_for_function!{

    fn myfunction(i:i32)->i32{
        i + 1
    }
    
}

fn main() {

    let value:i32;
    let seven:i32 = 7;

    // 式に対してマクロを適用
    mymacro::tokenstream_analyze_for_formula! {

        value = (seven + 5) * 2

    }

    print!("結果 {}",value);
}

extern crate proc_macro;

use std::{string, str::FromStr};

use proc_macro::TokenStream;


use syn::{
    parse_macro_input,
    Expr,
    ItemFn // "full" が必要
};


use quote::ToTokens;



// 関数
#[proc_macro]
pub fn tokenstream_analyze_for_function(input: TokenStream) -> TokenStream {

    // トークンストリームを解析
    let inputcopy = input.clone();
    let myinput:ItemFn = parse_macro_input!(inputcopy as ItemFn);

    println!("** 関数の構文木ができているか確認 *********************");
    // quoteを使って文字列化
    let astext = myinput.to_token_stream().to_string();
    println!("{}", astext);


    input
}


// 式
#[proc_macro]
pub fn tokenstream_analyze_for_formula(input: TokenStream) -> TokenStream {

    // トークンストリームを解析
    let inputcopy = input.clone();
    let myinput:Expr = parse_macro_input!(inputcopy as Expr);

    println!("** 式の構文木ができているか確認 *********************");
    // quoteを使って文字列化
    let astext = myinput.to_token_stream().to_string();
    println!("{}", astext);

    input
}

fn main() {

// 文字列でRustのコードを書く
    let my_rust_code = "
#[derive(Debug, Clone)]
#[inline]
pub fn myfunc(&self,x:i32, y:i32) -> f32{
  println!(\"Hello, world!\");
}
"
;
    // ソースコードのパース
    let my_parse = syn::parse_str::<syn::ItemFn>(my_rust_code).unwrap();

    let mut myfv:MyFnVisitor = MyFnVisitor{indent:0};
    myfv.visit_item_fn(&my_parse);

}

/////////////////////////////
/// 以下、解析のための構造体並びに関数

struct MyFnVisitor{
    indent:usize,
}

use quote::ToTokens;
use syn::visit::Visit;

impl<'a> syn::visit::Visit<'a> for MyFnVisitor{

    // 関数をパースするには、visit_item_fnを実装する
    fn visit_item_fn(&mut self, node: &'a syn::ItemFn) {

        let mut indentstr:String = "".to_string();
        for _ in 0..self.indent{
            indentstr.push_str(" ");
        }

        println!("{}****************",indentstr);

        // 関数がパブリックかどうかをチェック
        if let syn::Visibility::Public(_pub) = node.vis {
            println!("{}pub? {}",indentstr,_pub.to_token_stream().to_string());
        }

        // アトリビュートを取得
        for attr in &node.attrs{
            let id = attr.path().get_ident().unwrap();
            println!("{}attribute: {}",indentstr,id);
        }

        // 関数名を取得
        let function_name = &node.sig.ident;
        println!("{}func_name: {}",indentstr,function_name);

        // 引数を取得
        for arg in node.sig.inputs.iter(){
            match arg{

                syn::FnArg::Typed(pat_type) => {                    

                    if let syn::Pat::Ident(patident) = &*pat_type.pat{
                        let arg_name = &patident.ident;
                        let arg_type = &pat_type.ty.to_token_stream().to_string();
                        println!("{}arg: {} {}",indentstr,
                            &arg_name,
                            &arg_type
                        );
                    }
                }
                _ => {}
            }
        }

    }

}

extern crate mymacro;

fn main() {

    let value:i32;
    let seven:i32 = 7;
    

    mymacro::print_tokens! {

        value = (seven + 5) * 2;

    }

    print!("結果 {}",value);
}

extern crate proc_macro;

use proc_macro::TokenStream;

#[proc_macro]
pub fn print_tokens(input: TokenStream) -> TokenStream {

    // TokenStreamをStringに変換
    let input_str = input.to_string();
    println!("受け取ったトークン： {}", input_str);// ビルド時画面に表示

    // トークンの種類を特定
    for token in input.clone().into_iter() {                

        if let proc_macro::TokenTree::Literal( theItem ) = token{
            println!("これはリテラル    {}", theItem);
        }
        else if let proc_macro::TokenTree::Punct( theItem ) = token{
            println!("これは記号　      {}",theItem);
        }        
        else if let proc_macro::TokenTree::Ident( theItem ) = token{
            println!("これは識別子　     {}",theItem);
        }
        else if let proc_macro::TokenTree::Group( theItem ) = token{
            println!("これはグループ     {}", theItem);
        }
        else{
            println!("不明            {:?}", token);
        }

    };

    // 入力をそのまま返す
    input
}

extern crate proc_macro;

use std::{string, str::FromStr};

use proc_macro::TokenStream;

#[proc_macro]
pub fn print_tokens(input: TokenStream) -> TokenStream {

    // TokenStreamをStringに変換
    let input_str = input.to_string();
    println!("受け取ったトークン： {}", input_str);// ビルド時画面に表示

    // inputを書き換えることができないので、出力用のTokenStreamを作成
    let mut output = Vec::new();



    // トークン毎に処理
    for token in input.into_iter() {                

        // 所有権が移動しないように ref theItemとする
        if let proc_macro::TokenTree::Literal( ref theItem ) = token{
            println!("リテラルを発見    {}", theItem);

            let new_token;

            let ival = theItem.to_string().parse::<i32>().unwrap();// リテラルの値を取得
            if ival == 2{
                println!("リテラルの値が2の時だけtoken書き換え");
                // 新しいトークンを作成
                new_token = proc_macro::TokenTree::from(
                    proc_macro::Literal::i32_unsuffixed( ival * 2 /*二倍にする*/)
                );

                // 新しいトークンを出力用の配列に追加
                output.push(new_token);

            }
            else{          
                // ２以外の時はそのまま出力用の配列に追加     
                output.push(token.clone());
            }
        }
        else{
            // リテラル以外はそのまま出力用の配列に追加
            output.push(token.clone());
        }

    };


    // 新しく作成したトークンの配列をTokenStreamに変換して返却
    return TokenStream::from_iter(output);

}

extern crate proc_macro;

use proc_macro::TokenStream;

#[proc_macro]
pub fn print_tokens(input: TokenStream) -> TokenStream {
    // TokenStreamをStringに変換
    let input_str = input.to_string();

    // 画面に表示
    println!("Received TokenStream: {}", input_str);

    
    // inputを一つ一つのTokenに分割
    for tk in input.clone().into_iter() {                

        // 画面に表示
        println!("*** {}", tk);
    };


    // 入力をそのまま返す（または他のTokenStreamを返す）
    input
}

extern crate mymacro;


fn main() {

    let mut value=5;
    
    mymacro::print_tokens! {

        value = value + 5;

    }

    print!("hello world {} ",value);
}

// mylib/src/lib.rs
pub fn mylib_hello() {
    println!("Mylib: Hello, world!");
}

extern crate mylib;

fn main() {
    mylib::mylib_hello();
}

// MainFrm.h : CMainFrame クラスのインターフェイス
//

#pragma once
#include "ChildView.h"

class CMainFrame : public CFrameWnd
{
	
public:
	CMainFrame() noexcept;
protected: 
	DECLARE_DYNAMIC(CMainFrame)


/* 略 */

protected:  // コントロール バー用メンバー
	CToolBar          m_wndToolBar;
	CStatusBar        m_wndStatusBar;
	// 使用しない　CChildView    m_wndView; 

/* 略 */
};

int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
	if (CFrameWnd::OnCreate(lpCreateStruct) == -1)
		return -1;

	//// フレームのクライアント領域全体を占めるビューを作成します。
	//if (!m_wndView.Create(nullptr, nullptr, AFX_WS_DEFAULT_VIEW, CRect(0, 0, 0, 0), this, AFX_IDW_PANE_FIRST, nullptr))
	//{
	//	TRACE0("ビュー ウィンドウを作成できませんでした。\n");
	//	return -1;
	//}

	/* 略 */

	return 0;
}