[rustc.git] / src / vendor / syn-0.12.15 / src / op.rs

// Copyright 2018 Syn Developers
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

ast_enum! {
    /// A binary operator: `+`, `+=`, `&`.
    ///
    /// *This type is available if Syn is built with the `"derive"` or `"full"`
    /// feature.*
    #[cfg_attr(feature = "clone-impls", derive(Copy))]
    pub enum BinOp {
        /// The `+` operator (addition)
        Add(Token![+]),
        /// The `-` operator (subtraction)
        Sub(Token![-]),
        /// The `*` operator (multiplication)
        Mul(Token![*]),
        /// The `/` operator (division)
        Div(Token![/]),
        /// The `%` operator (modulus)
        Rem(Token![%]),
        /// The `&&` operator (logical and)
        And(Token![&&]),
        /// The `||` operator (logical or)
        Or(Token![||]),
        /// The `^` operator (bitwise xor)
        BitXor(Token![^]),
        /// The `&` operator (bitwise and)
        BitAnd(Token![&]),
        /// The `|` operator (bitwise or)
        BitOr(Token![|]),
        /// The `<<` operator (shift left)
        Shl(Token![<<]),
        /// The `>>` operator (shift right)
        Shr(Token![>>]),
        /// The `==` operator (equality)
        Eq(Token![==]),
        /// The `<` operator (less than)
        Lt(Token![<]),
        /// The `<=` operator (less than or equal to)
        Le(Token![<=]),
        /// The `!=` operator (not equal to)
        Ne(Token![!=]),
        /// The `>=` operator (greater than or equal to)
        Ge(Token![>=]),
        /// The `>` operator (greater than)
        Gt(Token![>]),
        /// The `+=` operator
        AddEq(Token![+=]),
        /// The `-=` operator
        SubEq(Token![-=]),
        /// The `*=` operator
        MulEq(Token![*=]),
        /// The `/=` operator
        DivEq(Token![/=]),
        /// The `%=` operator
        RemEq(Token![%=]),
        /// The `^=` operator
        BitXorEq(Token![^=]),
        /// The `&=` operator
        BitAndEq(Token![&=]),
        /// The `|=` operator
        BitOrEq(Token![|=]),
        /// The `<<=` operator
        ShlEq(Token![<<=]),
        /// The `>>=` operator
        ShrEq(Token![>>=]),
    }
}

ast_enum! {
    /// A unary operator: `*`, `!`, `-`.
    ///
    /// *This type is available if Syn is built with the `"derive"` or `"full"`
    /// feature.*
    #[cfg_attr(feature = "clone-impls", derive(Copy))]
    pub enum UnOp {
        /// The `*` operator for dereferencing
        Deref(Token![*]),
        /// The `!` operator for logical inversion
        Not(Token![!]),
        /// The `-` operator for negation
        Neg(Token![-]),
    }
}

#[cfg(feature = "parsing")]
pub mod parsing {
    use super::*;
    use synom::Synom;

    impl BinOp {
        named!(pub parse_binop -> Self, alt!(
            punct!(&&) => { BinOp::And }
            |
            punct!(||) => { BinOp::Or }
            |
            punct!(<<) => { BinOp::Shl }
            |
            punct!(>>) => { BinOp::Shr }
            |
            punct!(==) => { BinOp::Eq }
            |
            punct!(<=) => { BinOp::Le }
            |
            punct!(!=) => { BinOp::Ne }
            |
            punct!(>=) => { BinOp::Ge }
            |
            punct!(+) => { BinOp::Add }
            |
            punct!(-) => { BinOp::Sub }
            |
            punct!(*) => { BinOp::Mul }
            |
            punct!(/) => { BinOp::Div }
            |
            punct!(%) => { BinOp::Rem }
            |
            punct!(^) => { BinOp::BitXor }
            |
            punct!(&) => { BinOp::BitAnd }
            |
            punct!(|) => { BinOp::BitOr }
            |
            punct!(<) => { BinOp::Lt }
            |
            punct!(>) => { BinOp::Gt }
        ));

        #[cfg(feature = "full")]
        named!(pub parse_assign_op -> Self, alt!(
            punct!(+=) => { BinOp::AddEq }
            |
            punct!(-=) => { BinOp::SubEq }
            |
            punct!(*=) => { BinOp::MulEq }
            |
            punct!(/=) => { BinOp::DivEq }
            |
            punct!(%=) => { BinOp::RemEq }
            |
            punct!(^=) => { BinOp::BitXorEq }
            |
            punct!(&=) => { BinOp::BitAndEq }
            |
            punct!(|=) => { BinOp::BitOrEq }
            |
            punct!(<<=) => { BinOp::ShlEq }
            |
            punct!(>>=) => { BinOp::ShrEq }
        ));
    }

    impl Synom for UnOp {
        named!(parse -> Self, alt!(
            punct!(*) => { UnOp::Deref }
            |
            punct!(!) => { UnOp::Not }
            |
            punct!(-) => { UnOp::Neg }
        ));

        fn description() -> Option<&'static str> {
            Some("unary operator: `*`, `!`, or `-`")
        }
    }
}

#[cfg(feature = "printing")]
mod printing {
    use super::*;
    use quote::{ToTokens, Tokens};

    impl ToTokens for BinOp {
        fn to_tokens(&self, tokens: &mut Tokens) {
            match *self {
                BinOp::Add(ref t) => t.to_tokens(tokens),
                BinOp::Sub(ref t) => t.to_tokens(tokens),
                BinOp::Mul(ref t) => t.to_tokens(tokens),
                BinOp::Div(ref t) => t.to_tokens(tokens),
                BinOp::Rem(ref t) => t.to_tokens(tokens),
                BinOp::And(ref t) => t.to_tokens(tokens),
                BinOp::Or(ref t) => t.to_tokens(tokens),
                BinOp::BitXor(ref t) => t.to_tokens(tokens),
                BinOp::BitAnd(ref t) => t.to_tokens(tokens),
                BinOp::BitOr(ref t) => t.to_tokens(tokens),
                BinOp::Shl(ref t) => t.to_tokens(tokens),
                BinOp::Shr(ref t) => t.to_tokens(tokens),
                BinOp::Eq(ref t) => t.to_tokens(tokens),
                BinOp::Lt(ref t) => t.to_tokens(tokens),
                BinOp::Le(ref t) => t.to_tokens(tokens),
                BinOp::Ne(ref t) => t.to_tokens(tokens),
                BinOp::Ge(ref t) => t.to_tokens(tokens),
                BinOp::Gt(ref t) => t.to_tokens(tokens),
                BinOp::AddEq(ref t) => t.to_tokens(tokens),
                BinOp::SubEq(ref t) => t.to_tokens(tokens),
                BinOp::MulEq(ref t) => t.to_tokens(tokens),
                BinOp::DivEq(ref t) => t.to_tokens(tokens),
                BinOp::RemEq(ref t) => t.to_tokens(tokens),
                BinOp::BitXorEq(ref t) => t.to_tokens(tokens),
                BinOp::BitAndEq(ref t) => t.to_tokens(tokens),
                BinOp::BitOrEq(ref t) => t.to_tokens(tokens),
                BinOp::ShlEq(ref t) => t.to_tokens(tokens),
                BinOp::ShrEq(ref t) => t.to_tokens(tokens),
            }
        }
    }

    impl ToTokens for UnOp {
        fn to_tokens(&self, tokens: &mut Tokens) {
            match *self {
                UnOp::Deref(ref t) => t.to_tokens(tokens),
                UnOp::Not(ref t) => t.to_tokens(tokens),
                UnOp::Neg(ref t) => t.to_tokens(tokens),
            }
        }
    }
}
Commit	Line	Data
83c7162d XL	1	// Copyright 2018 Syn Developers
	2	//
	3	// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
	4	// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
	5	// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
	6	// option. This file may not be copied, modified, or distributed
	7	// except according to those terms.
	8
	9	ast_enum! {
	10	/// A binary operator: `+`, `+=`, `&`.
	11	///
	12	/// *This type is available if Syn is built with the `"derive"` or `"full"`
	13	/// feature.*
	14	#[cfg_attr(feature = "clone-impls", derive(Copy))]
	15	pub enum BinOp {
	16	/// The `+` operator (addition)
	17	Add(Token![+]),
	18	/// The `-` operator (subtraction)
	19	Sub(Token![-]),
	20	/// The `*` operator (multiplication)
	21	Mul(Token![*]),
	22	/// The `/` operator (division)
	23	Div(Token![/]),
	24	/// The `%` operator (modulus)
	25	Rem(Token![%]),
	26	/// The `&&` operator (logical and)
	27	And(Token![&&]),
	28	/// The `\|\|` operator (logical or)
	29	Or(Token![\|\|]),
	30	/// The `^` operator (bitwise xor)
	31	BitXor(Token![^]),
	32	/// The `&` operator (bitwise and)
	33	BitAnd(Token![&]),
	34	/// The `\|` operator (bitwise or)
	35	BitOr(Token![\|]),
	36	/// The `<<` operator (shift left)
	37	Shl(Token![<<]),
	38	/// The `>>` operator (shift right)
	39	Shr(Token![>>]),
	40	/// The `==` operator (equality)
	41	Eq(Token![==]),
	42	/// The `<` operator (less than)
	43	Lt(Token![<]),
	44	/// The `<=` operator (less than or equal to)
	45	Le(Token![<=]),
	46	/// The `!=` operator (not equal to)
	47	Ne(Token![!=]),
	48	/// The `>=` operator (greater than or equal to)
	49	Ge(Token![>=]),
	50	/// The `>` operator (greater than)
	51	Gt(Token![>]),
	52	/// The `+=` operator
	53	AddEq(Token![+=]),
	54	/// The `-=` operator
	55	SubEq(Token![-=]),
	56	/// The `*=` operator
	57	MulEq(Token![*=]),
	58	/// The `/=` operator
	59	DivEq(Token![/=]),
	60	/// The `%=` operator
	61	RemEq(Token![%=]),
	62	/// The `^=` operator
	63	BitXorEq(Token![^=]),
	64	/// The `&=` operator
65	BitAndEq(Token![&=]),
66	/// The `\|=` operator
67	BitOrEq(Token![\|=]),
68	/// The `<<=` operator
69	ShlEq(Token![<<=]),
70	/// The `>>=` operator
71	ShrEq(Token![>>=]),
72	}
73	}
74
75	ast_enum! {
76	/// A unary operator: `*`, `!`, `-`.
77	///
78	/// *This type is available if Syn is built with the `"derive"` or `"full"`
79	/// feature.*
80	#[cfg_attr(feature = "clone-impls", derive(Copy))]
81	pub enum UnOp {
82	/// The `*` operator for dereferencing
83	Deref(Token![*]),
84	/// The `!` operator for logical inversion
85	Not(Token![!]),
86	/// The `-` operator for negation
87	Neg(Token![-]),
88	}
89	}
90
91	#[cfg(feature = "parsing")]
92	pub mod parsing {
93	use super::*;
94	use synom::Synom;
95
96	impl BinOp {
97	named!(pub parse_binop -> Self, alt!(
98	punct!(&&) => { BinOp::And }
99	\|
100	punct!(\|\|) => { BinOp::Or }
101	\|
102	punct!(<<) => { BinOp::Shl }
103	\|
104	punct!(>>) => { BinOp::Shr }
105	\|
106	punct!(==) => { BinOp::Eq }
107	\|
108	punct!(<=) => { BinOp::Le }
109	\|
110	punct!(!=) => { BinOp::Ne }
111	\|
112	punct!(>=) => { BinOp::Ge }
113	\|
114	punct!(+) => { BinOp::Add }
115	\|
116	punct!(-) => { BinOp::Sub }
117	\|
118	punct!(*) => { BinOp::Mul }
119	\|
120	punct!(/) => { BinOp::Div }
121	\|
122	punct!(%) => { BinOp::Rem }
123	\|
124	punct!(^) => { BinOp::BitXor }
125	\|
126	punct!(&) => { BinOp::BitAnd }
127	\|
128	punct!(\|) => { BinOp::BitOr }
129	\|
130	punct!(<) => { BinOp::Lt }
131	\|
132	punct!(>) => { BinOp::Gt }
133	));
134
135	#[cfg(feature = "full")]
136	named!(pub parse_assign_op -> Self, alt!(
137	punct!(+=) => { BinOp::AddEq }
138	\|
139	punct!(-=) => { BinOp::SubEq }
140	\|
141	punct!(*=) => { BinOp::MulEq }
142	\|
143	punct!(/=) => { BinOp::DivEq }
144	\|
145	punct!(%=) => { BinOp::RemEq }
146	\|
147	punct!(^=) => { BinOp::BitXorEq }
148	\|
149	punct!(&=) => { BinOp::BitAndEq }
150	\|
151	punct!(\|=) => { BinOp::BitOrEq }
152	\|
153	punct!(<<=) => { BinOp::ShlEq }
154	\|
155	punct!(>>=) => { BinOp::ShrEq }
156	));
157	}
158
159	impl Synom for UnOp {
160	named!(parse -> Self, alt!(
161	punct!(*) => { UnOp::Deref }
162	\|
163	punct!(!) => { UnOp::Not }
164	\|
165	punct!(-) => { UnOp::Neg }
166	));
167
168	fn description() -> Option<&'static str> {
169	Some("unary operator: `*`, `!`, or `-`")
170	}
171	}
172	}
173
174	#[cfg(feature = "printing")]
175	mod printing {
176	use super::*;
177	use quote::{ToTokens, Tokens};
178
179	impl ToTokens for BinOp {
180	fn to_tokens(&self, tokens: &mut Tokens) {
181	match *self {
182	BinOp::Add(ref t) => t.to_tokens(tokens),
183	BinOp::Sub(ref t) => t.to_tokens(tokens),
184	BinOp::Mul(ref t) => t.to_tokens(tokens),
185	BinOp::Div(ref t) => t.to_tokens(tokens),
186	BinOp::Rem(ref t) => t.to_tokens(tokens),
187	BinOp::And(ref t) => t.to_tokens(tokens),
188	BinOp::Or(ref t) => t.to_tokens(tokens),
189	BinOp::BitXor(ref t) => t.to_tokens(tokens),
190	BinOp::BitAnd(ref t) => t.to_tokens(tokens),
191	BinOp::BitOr(ref t) => t.to_tokens(tokens),
192	BinOp::Shl(ref t) => t.to_tokens(tokens),
193	BinOp::Shr(ref t) => t.to_tokens(tokens),
194	BinOp::Eq(ref t) => t.to_tokens(tokens),
195	BinOp::Lt(ref t) => t.to_tokens(tokens),
196	BinOp::Le(ref t) => t.to_tokens(tokens),
197	BinOp::Ne(ref t) => t.to_tokens(tokens),
198	BinOp::Ge(ref t) => t.to_tokens(tokens),
199	BinOp::Gt(ref t) => t.to_tokens(tokens),
200	BinOp::AddEq(ref t) => t.to_tokens(tokens),
201	BinOp::SubEq(ref t) => t.to_tokens(tokens),
202	BinOp::MulEq(ref t) => t.to_tokens(tokens),
203	BinOp::DivEq(ref t) => t.to_tokens(tokens),
204	BinOp::RemEq(ref t) => t.to_tokens(tokens),
205	BinOp::BitXorEq(ref t) => t.to_tokens(tokens),
206	BinOp::BitAndEq(ref t) => t.to_tokens(tokens),
207	BinOp::BitOrEq(ref t) => t.to_tokens(tokens),
208	BinOp::ShlEq(ref t) => t.to_tokens(tokens),
209	BinOp::ShrEq(ref t) => t.to_tokens(tokens),
210	}
211	}
212	}
213
214	impl ToTokens for UnOp {
215	fn to_tokens(&self, tokens: &mut Tokens) {
216	match *self {
217	UnOp::Deref(ref t) => t.to_tokens(tokens),
218	UnOp::Not(ref t) => t.to_tokens(tokens),
219	UnOp::Neg(ref t) => t.to_tokens(tokens),
220	}
221	}
222	}
223	}