compiler/src/main/java/org/apache/etch/compiler/opt/Authorize.java - etch - Git at Google

 /* $Id$
  *
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements. See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership. The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License. You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied. See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */

 package org.apache.etch.compiler.opt;

 import java.util.ArrayList;
 import java.util.List;
 import java.util.StringTokenizer;

 import org.apache.etch.compiler.EtchGrammarConstants;
 import org.apache.etch.compiler.ParseException;
 import org.apache.etch.compiler.Token;
 import org.apache.etch.compiler.ast.Constant;
 import org.apache.etch.compiler.ast.Enumx;
 import org.apache.etch.compiler.ast.Item;
 import org.apache.etch.compiler.ast.Message;
 import org.apache.etch.compiler.ast.Name;
 import org.apache.etch.compiler.ast.Named;
 import org.apache.etch.compiler.ast.Opt;
 import org.apache.etch.compiler.ast.Parameter;
 import org.apache.etch.compiler.ast.Service;
 import org.apache.etch.compiler.ast.Struct;
 import org.apache.etch.compiler.ast.TypeRef;
 import org.apache.etch.util.StringUtil;


 /**
  * Option which sets the authorization method for a message.
  */
 public class Authorize extends Opt
 {
 	/**
 	 * Constructs the Authorize.
 	 *
 	 * @param name
 	 * @param args
 	 * @throws ParseException
 	 */
 	public Authorize( Name name, Token... args ) throws ParseException
 	{
 		super( name.name, name.token.beginLine );
 		addType( Message.class );
 		addType( Service.class );

 		if (args == null || args.length == 0)
 		{
 			method = new Token();
 			method.kind = EtchGrammarConstants.TRUE;
 			method.beginLine = name.token.beginLine;
 			argList = new ArrayList<AuthArg>();
 			return;
 		}

 		method = args[0];
 		if (method.kind != EtchGrammarConstants.ID &&
 				method.kind != EtchGrammarConstants.TRUE &&
 				method.kind != EtchGrammarConstants.FALSE)
 		{
 			throw new ParseException( String.format(
 				"Authorize method should be identifier, true, or false (but not %s) at line %d",
 				method, method.beginLine ) );
 		}

 		if ((method.kind == EtchGrammarConstants.TRUE ||
 				method.kind == EtchGrammarConstants.FALSE) && args.length > 1)
 		{
 			throw new ParseException( String.format(
 				"Authorize %d cannot have any args at line %d",
 				method, method.beginLine ) );
 		}

 		argList = argsToArgList( args );
 	}

 	private final Token method;

 	private final List<AuthArg> argList;

 	/**
 	 * @return the authorization method.
 	 */
 	public Token method()
 	{
 		return method;
 	}

 	@Override
 	public void dump( String indent )
 	{
 		System.out.printf( "%s@Authorize( %s, %s )\n", indent, method, argList );
 	}

 	@Override
 	public String toString()
 	{
 		return String.format( "@Authorize( %s, %s )", method, argList );
 	}

 	/**
 	 * @return args as a list.
 	 */
 	private List<AuthArg> argsToArgList( Token[] args )
 	{
 		List<AuthArg> list = new ArrayList<AuthArg>();
 		int n = args.length;
 		for (int i = 1; i < n; i++)
 			list.add( new AuthArg( args[i] ) );
 		return list;
 	}

 	/**
 	 * @return the args for the authorization method.
 	 */
 	public List<AuthArg> args()
 	{
 		return argList;
 	}

 	/**
 	 * @return true if the message needs authorization.
 	 */
 	public boolean hasAuth()
 	{
 		return method != null && method.kind != EtchGrammarConstants.TRUE;
 	}

 	/**
 	 * Checks the method to be called by authorize to make sure it is
 	 * a service method and that the parameters are correct.
 	 * @param service our service definition
 	 * @param msg the message being protected by the auth
 	 * @throws ParseException
 	 */
 	public void check( Service service, Message msg ) throws ParseException
 	{
 		if (!hasAuth())
 			return;

 		if (isMethodTrue() || isMethodFalse())
 			return;

 		Named<?> named = service.get( method.image );
 		if (named == null)
 			throw new ParseException( String.format(
 				"Authorize method name %s is not defined at %d",
 					method.image, lineno() ) );

 		if (!named.isMessage())
 			throw new ParseException( String.format(
 				"Authorize method name %s is not a method at %d",
 				method.image, lineno() ) );

 		Message authMsg = (Message) named;

 		if (authMsg.type().type().kind != EtchGrammarConstants.BOOLEAN)
 			throw new ParseException( String.format(
 				"Authorize method %s result type is not boolean at %d",
 				method.image, lineno() ) );

 		List<Parameter> authParams = authMsg.getParameters();
 		if (authParams.size() != argList.size())
 			throw new ParseException( String.format(
 				"Authorize method %s parameter list size does not match the number of supplied arguments at %d",
 				method.image, lineno() ) );

 		int n = argList.size();
 		for (int i = 0; i < n; i++)
 		{
 			Parameter param = authParams.get( i );
 			AuthArg aarg = argList.get( i );
 			aarg.setType( param.type() );
 			Token arg = aarg.value();

 //			System.out.printf( "auth method %s param %s = %s\n",
 //				method, param.name(), arg );

 			switch (arg.kind)
 			{
 				case EtchGrammarConstants.NULL:
 					// any parameter value may be specified as null...
 					break;

 				case EtchGrammarConstants.ID:
 					// arg is referencing either a parameter of msg or a
 					// service constant.
 					checkMsgParamOrServiceConst( msg, param, arg, i );
 					break;

 				case EtchGrammarConstants.QID:
 					// arg is referencing an enum item (enum.item) or
 					// could be trying to reference a field of a
 					// parameter of message (param(.field)+).
 					checkMsgParamFieldRefOrEnumItem( msg, param, arg, i );
 					break;

 				case EtchGrammarConstants.TRUE:
 				case EtchGrammarConstants.FALSE:
 					// arg is a boolean constant the parameter better be
 					// boolean, too.
 					checkBooleanConstant( param, arg, i );
 					break;

 				case EtchGrammarConstants.INTEGER:
 					// arg is an integer constant, the parameter better
 					// be an integral or floating type and arg better
 					// be the right size...
 					checkIntegerConstant( param, arg, i );
 					break;

 				case EtchGrammarConstants.OCTAL:
 					// arg is an octal constant, the parameter better
 					// be an integral or floating type and arg better
 					// be the right size...
 					checkOctalConstant( param, arg, i );
 					break;

 				case EtchGrammarConstants.HEX:
 					// arg is a hex constant, the parameter better
 					// be an integral or floating type and arg better
 					// be the right size...
 					checkHexConstant( param, arg, i );
 					break;

 				case EtchGrammarConstants.BINARY:
 					// arg is a binary constant, the parameter better
 					// be an integral or floating type and arg better
 					// be the right size...
 					checkBinaryConstant( param, arg, i );
 					break;

 				case EtchGrammarConstants.DECIMAL:
 					// arg is a decimal constant, the parameter better
 					// be a floating type and arg better be the right
 					// size...
 					checkDecimalConstant( param, arg, i );
 					break;

 				case EtchGrammarConstants.STR:
 					// arg is a string constant the parameter better be
 					// string, too.
 					checkStringConstant( param, arg, i );
 					break;

 				default:
 					throw new ParseException( String.format(
 						"Authorize method %s arg %d unsupported kind (%s) at line %d",
 						method.image, i+1, arg, lineno() ) );
 			}
 		}
 	}

 	/**
 	 * @return true if the method is false.
 	 */
 	public boolean isMethodFalse()
     {
 //		System.out.println( "isMethodFalse() => "+(method.kind == EtchGrammarConstants.FALSE) );
 	    return method.kind == EtchGrammarConstants.FALSE;
     }

 	/**
 	 * @return true if the method is true.
 	 */
 	public boolean isMethodTrue()
     {
 	    return method.kind == EtchGrammarConstants.TRUE;
     }

 	private void checkMsgParamOrServiceConst( Message msg, Parameter param,
 		Token arg, int argNo ) throws ParseException
 	{
 		Parameter p = msg.getParameter( arg.image );
 		if (p != null)
 		{
 			// it's a parameter, do the types match?

 			Named<?> pt = p.type().getNamed( msg.parent() );
 			Named<?> paramType = param.type().getNamed( msg.parent() );
 			if (pt == paramType)
 				return;

 			throw typeMismatch( param, arg, argNo );
 		}

 		Named<?> named = msg.parent().get( arg.image );

 		if (named != null)
 		{
 			// it's a named thing, it is a constant and do the
 			// types match?

 			if (named.isConstant())
 			{
 				Constant c = (Constant) named;

 				// it's a constant, do the types match?

 				Named<?> ct = c.type().getNamed( msg.parent() );
 				Named<?> paramType = param.type().getNamed( msg.parent() );
 				if (ct == paramType)
 					return;

 				throw typeMismatch( param, arg, argNo );
 			}

 			// the named thing is not a constant, so blow chunks.

 			throw new ParseException( String.format(
 				"Authorize method %s arg %d name not a parameter or constant (%s) at line %d",
 				method.image, argNo+1, arg, lineno() ) );
 		}

 		// the named thing does not exist, so blow chunks.

 		throw new ParseException( String.format(
 			"Authorize method %s arg %d name unknown (%s) at line %d",
 			method.image, argNo+1, arg, lineno() ) );
 	}

 	private void checkMsgParamFieldRefOrEnumItem( Message msg, Parameter param,
 		Token arg, int argNo ) throws ParseException
 	{
 		Service service = msg.parent();

 		StringTokenizer path = new StringTokenizer( arg.image, "." );
 		String name = path.nextToken();

 		Parameter p = msg.getParameter( name );
 		if (p != null)
 		{
 			// it's a parameter, so type of p must be a struct...

 			p = getField( service, p, path );

 			if (p == null)
 				throw new ParseException( String.format(
 					"Authorize method %s arg %d name does not resolve to a field (%s) at line %d",
 					method.image, argNo+1, arg, lineno() ) );

 			Named<?> pt = p.type().getNamed( service );
 			Named<?> paramType = param.type().getNamed( service );
 			if (pt == paramType)
 				return;

 			throw typeMismatch( param, arg, argNo );
 		}

 		// it isn't a parameter, so it must be an enum...

 		Named<?> named = service.get( name );
 		if (named == null)
 			throw new ParseException( String.format(
 				"Authorize method %s arg %d name unknown (%s) at line %d",
 				method.image, argNo+1, arg, lineno() ) );

 		if (!named.isEnumx())
 			throw new ParseException( String.format(
 				"Authorize method %s arg %d name not a parameter field or enum (%s) at line %d",
 				method.image, argNo+1, arg, lineno() ) );

 		Enumx e = (Enumx) named;

 		Item i = e.getItem( path.nextToken() );
 		if (i == null)
 			throw new ParseException( String.format(
 				"Authorize method %s arg %d name not an enum item (%s) at line %d",
 				method.image, argNo+1, arg, lineno() ) );

 		if (path.hasMoreTokens())
 			throw new ParseException( String.format(
 				"Authorize method %s arg %d name not an enum item (%s) at line %d",
 				method.image, argNo+1, arg, lineno() ) );
 	}

 	/**
 	 * @param service
 	 * @param p
 	 * @param path
 	 * @return the parameter that was resolved using the tokens from st.
 	 */
 	private Parameter getField( Service service, Parameter p, StringTokenizer path )
 	{
 		if (!path.hasMoreTokens())
 			return p;

 		String name = path.nextToken();

 		// get the type of p, it better be a struct.

 		Named<?> named = p.type().getNamed( service );
 		if (named == null || !named.isStruct())
 			return null;

 		Struct s = (Struct) named;

 		p = s.getParameter( name );
 		if (p == null)
 			return null;

 		return getField( service, p, path );
 	}

 	private void checkBooleanConstant( Parameter param, Token arg, int argNo )
 		throws ParseException
 	{
 		if (!param.type().isBoolean())
 			throw typeMismatch( param, arg, argNo );
 	}

 	private ParseException typeMismatch( Parameter param, Token arg, int argNo )
 	{
 		//if (true) throw new RuntimeException( "type mismatch" );
 		return new ParseException( String.format(
 			"Authorize method %s parameter %d (%s) type mismatch at line %d",
 			method, argNo+1, param.name(), arg.beginLine ) );
 	}

 	private void checkIntegerConstant( Parameter param, Token arg, int argNo )
 		throws ParseException
 	{
 		if (!(param.type().isIntegral() || param.type().isFloating()))
 			throw typeMismatch( param, arg, argNo );

 		Long value = parseLong( arg.image, 10, "" );
 		if (value != null)
 		{
 			// check range of long vs. integral or floating param type
 			if (checkRange( value, param, arg, argNo ))
 				return;
 		}

 		// value range is too much for long type, or parameter is not a
 		// known integral or floating type; try double

 		Double dvalue = parseDouble( arg.image );
 		if (dvalue != null)
 		{
 			// check range of double vs. floating param type
 			if (checkRange( dvalue, param, arg, argNo ))
 				return;
 		}

 		// value range is too much for long or double type, or parameter
 		// is not a known integral or floating type

 		throw typeMismatch( param, arg, argNo );
 	}

 	private boolean checkRange( long value, Parameter param, Token arg,
 		int argNo ) throws ParseException
 	{
 		// we parsed the value as a long, now see if it is compatible with
 		// our parameter type.
 		switch (param.type().type().kind)
 		{
 			case EtchGrammarConstants.BYTE:
 				checkRange( value, Byte.MIN_VALUE, Byte.MAX_VALUE, param, arg,
 					argNo );
 				return true;

 			case EtchGrammarConstants.SHORT:
 				checkRange( value, Short.MIN_VALUE, Short.MAX_VALUE, param, arg,
 					argNo );
 				return true;

 			case EtchGrammarConstants.INT:
 				checkRange( value, Integer.MIN_VALUE, Integer.MAX_VALUE, param,
 					arg, argNo );
 				return true;

 			case EtchGrammarConstants.LONG:
 			case EtchGrammarConstants.FLOAT:
 			case EtchGrammarConstants.DOUBLE:
 				// value is a long, and that is certainly compatible with long,
 				// float, or double.
 				return true;

 			default:
 				// parameter is not a recognized type.
 				return false;
 		}
 	}

 	private boolean checkRange( double dvalue, Parameter param, Token arg,
 		int argNo ) throws ParseException
 	{
 		// we parsed the value as a double, now see if it is compatible with
 		// our parameter type.
 		switch (param.type().type().kind)
 		{
 			case EtchGrammarConstants.FLOAT:
 				checkRange( dvalue, Float.MIN_VALUE, Float.MAX_VALUE, param,
 					arg, argNo );
 				return true;

 			case EtchGrammarConstants.DOUBLE:
 				// value is a double, and that is certainly compatible with
 				// double.
 				return true;

 			default:
 				// parameter is not a recognized type.
 				return false;
 		}
 	}

 	private void checkRange( long value, long min, long max, Parameter param,
 		Token arg, int argNo ) throws ParseException
 	{
 		if (value >= min && value <= max)
 			return;

 		throw new ParseException( String.format(
 			"Authorize method %s parameter %d (%s) integral value out of range at line %d",
 			method, argNo+1, param.name(), arg.beginLine ) );
 	}

 	private void checkRange( double dvalue, double min, double max,
 		Parameter param, Token arg, int argNo ) throws ParseException
 	{
 		// ignore sign, it doesn't matter.

 		dvalue = Math.abs( dvalue );

 		if (dvalue >= min && dvalue <= max)
 			return;

 		throw new ParseException( String.format(
 			"Authorize method %s parameter %d (%s) floating value out of range at line %d",
 			method, argNo+1, param.name(), arg.beginLine ) );
 	}

 	private Long parseLong( String s, int radix, String prefix )
 	{
 		try
 		{
 			if (!s.toLowerCase().startsWith( prefix ))
 				return null;
 			return Long.parseLong( s.substring( prefix.length() ), radix );
 		}
 		catch ( NumberFormatException e )
 		{
 			return null;
 		}
 	}

 	private Double parseDouble( String image )
 	{
 		try
 		{
 			return Double.parseDouble( image );
 		}
 		catch ( NumberFormatException e )
 		{
 			return null;
 		}
 	}

 	private void checkOctalConstant( Parameter param, Token arg, int argNo )
 		throws ParseException
 	{
 		if (!param.type().isIntegral())
 			throw typeMismatch( param, arg, argNo );

 		Long value = parseLong( arg.image, 8, "0" );
 		if (value != null)
 		{
 			// check range of long vs. integral or floating param type
 			if (checkRange( value, param, arg, argNo ))
 				return;
 		}

 		// value range is too much for long or double type, or parameter
 		// is not a known integral or floating type

 		throw typeMismatch( param, arg, argNo );
 	}

 	private void checkHexConstant( Parameter param, Token arg, int argNo )
 		throws ParseException
 	{
 		if (!param.type().isIntegral())
 			throw typeMismatch( param, arg, argNo );

 		Long value = parseLong( arg.image, 16, "0x" );
 		if (value != null)
 		{
 			// check range of long vs. integral or floating param type
 			if (checkRange( value, param, arg, argNo ))
 				return;
 		}

 		// value range is too much for long or double type, or parameter
 		// is not a known integral or floating type

 		throw typeMismatch( param, arg, argNo );
 	}

 	private void checkBinaryConstant( Parameter param, Token arg, int argNo )
 		throws ParseException
 	{
 		if (!param.type().isIntegral())
 			throw typeMismatch( param, arg, argNo );

 		Long value = parseLong( arg.image, 2, "0b" );
 		if (value != null)
 		{
 			// check range of long vs. integral or floating param type
 			if (checkRange( value, param, arg, argNo ))
 				return;
 		}

 		// value range is too much for long or double type, or parameter
 		// is not a known integral or floating type

 		throw typeMismatch( param, arg, argNo );
 	}

 	private void checkDecimalConstant( Parameter param, Token arg, int argNo )
 		throws ParseException
 	{
 		if (!param.type().isFloating())
 			throw typeMismatch( param, arg, argNo );

 		Double dvalue = parseDouble( arg.image );
 		if (dvalue != null)
 		{
 			// check range of double vs. floating param type
 			if (checkRange( dvalue, param, arg, argNo ))
 				return;
 		}

 		// value range is too much for long or double type, or parameter
 		// is not a known integral or floating type

 		throw typeMismatch( param, arg, argNo );
 	}

 	private void checkStringConstant( Parameter param, Token arg, int argNo )
 		throws ParseException
 	{
 		if (!param.type().isString())
 			throw typeMismatch( param, arg, argNo );
 	}

 	/**
 	 * Wrapper for arg which holds the required arg type as well.
 	 */
 	public static class AuthArg
 	{
 		/**
 		 * @param arg
 		 */
 		public AuthArg( Token arg )
 		{
 			this.arg = arg;
 		}

 		private final Token arg;

 		private TypeRef type;

 		/**
 		 * @return the token of the arg.
 		 */
 		public Token value()
 		{
 			return arg;
 		}

 		/**
 		 * Sets the required type of the arg.
 		 * @param type
 		 */
 		public void setType( TypeRef type )
 		{
 			this.type = type;
 		}

 		/**
 		 * @return the required type of the arg.
 		 */
 		public TypeRef type()
 		{
 			return type;
 		}

 		/**
 		 * @return true if not an id or qid.
 		 */
 		public boolean isLiteralConstant()
 		{
 			switch (arg.kind)
 			{
 				case EtchGrammarConstants.TRUE:
 				case EtchGrammarConstants.FALSE:
 				case EtchGrammarConstants.INTEGER:
 				case EtchGrammarConstants.OCTAL:
 				case EtchGrammarConstants.HEX:
 				case EtchGrammarConstants.BINARY:
 				case EtchGrammarConstants.DECIMAL:
 				case EtchGrammarConstants.STR:
 					return true;
 				default:
 					return false;
 			}
 		}

 		/**
 		 * @param msg
 		 * @return true if this names a parameter of the protected
 		 * method.
 		 */
 		public boolean isParameter( Message msg )
 		{
 			switch (arg.kind)
 			{
 				case EtchGrammarConstants.ID:
 					return msg.hasParameter( arg.image );

 				case EtchGrammarConstants.QID:
 				{
 					String[] n = StringUtil.leftSplit( arg.image, '.' );
 					return msg.hasParameter( n[0] );
 				}

 				default:
 					return false;
 			}
 		}

 		/**
 		 * @param intf
 		 * @return true if this names a constant of the service.
 		 */
 		public boolean isConstant( Service intf )
 		{
 			if (arg.kind != EtchGrammarConstants.ID
 					&& arg.kind != EtchGrammarConstants.QID)
 				return false;

 			Named<?> named = intf.get( arg.image );

 			return named != null && named.isConstant();
 		}

 		/**
 		 * @param intf
 		 * @return true if this names an enum of the service.
 		 */
 		public boolean isEnum( Service intf )
 		{
 			if (arg.kind != EtchGrammarConstants.QID)
 				return false;

 			String[] n = StringUtil.leftSplit( arg.image, '.' );

 			Named<?> named = intf.get( n[0] );

 			return named != null && named.isEnumx();
 		}
 	}
 }
	/* $Id$
	*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/

	package org.apache.etch.compiler.opt;

	import java.util.ArrayList;
	import java.util.List;
	import java.util.StringTokenizer;

	import org.apache.etch.compiler.EtchGrammarConstants;
	import org.apache.etch.compiler.ParseException;
	import org.apache.etch.compiler.Token;
	import org.apache.etch.compiler.ast.Constant;
	import org.apache.etch.compiler.ast.Enumx;
	import org.apache.etch.compiler.ast.Item;
	import org.apache.etch.compiler.ast.Message;
	import org.apache.etch.compiler.ast.Name;
	import org.apache.etch.compiler.ast.Named;
	import org.apache.etch.compiler.ast.Opt;
	import org.apache.etch.compiler.ast.Parameter;
	import org.apache.etch.compiler.ast.Service;
	import org.apache.etch.compiler.ast.Struct;
	import org.apache.etch.compiler.ast.TypeRef;
	import org.apache.etch.util.StringUtil;


	/**
	* Option which sets the authorization method for a message.
	*/
	public class Authorize extends Opt
	{
	/**
	* Constructs the Authorize.
	*
	* @param name
	* @param args
	* @throws ParseException
	*/
	public Authorize( Name name, Token... args ) throws ParseException
	{
	super( name.name, name.token.beginLine );
	addType( Message.class );
	addType( Service.class );

	if (args == null \|\| args.length == 0)
	{
	method = new Token();
	method.kind = EtchGrammarConstants.TRUE;
	method.beginLine = name.token.beginLine;
	argList = new ArrayList<AuthArg>();
	return;
	}

	method = args[0];
	if (method.kind != EtchGrammarConstants.ID &&
	method.kind != EtchGrammarConstants.TRUE &&
	method.kind != EtchGrammarConstants.FALSE)
	{
	throw new ParseException( String.format(
	"Authorize method should be identifier, true, or false (but not %s) at line %d",
	method, method.beginLine ) );
	}

	if ((method.kind == EtchGrammarConstants.TRUE \|\|
	method.kind == EtchGrammarConstants.FALSE) && args.length > 1)
	{
	throw new ParseException( String.format(
	"Authorize %d cannot have any args at line %d",
	method, method.beginLine ) );
	}

	argList = argsToArgList( args );
	}

	private final Token method;

	private final List<AuthArg> argList;

	/**
	* @return the authorization method.
	*/
	public Token method()
	{
	return method;
	}

	@Override
	public void dump( String indent )
	{
	System.out.printf( "%s@Authorize( %s, %s )\n", indent, method, argList );
	}

	@Override
	public String toString()
	{
	return String.format( "@Authorize( %s, %s )", method, argList );
	}

	/**
	* @return args as a list.
	*/
	private List<AuthArg> argsToArgList( Token[] args )
	{
	List<AuthArg> list = new ArrayList<AuthArg>();
	int n = args.length;
	for (int i = 1; i < n; i++)
	list.add( new AuthArg( args[i] ) );
	return list;
	}

	/**
	* @return the args for the authorization method.
	*/
	public List<AuthArg> args()
	{
	return argList;
	}

	/**
	* @return true if the message needs authorization.
	*/
	public boolean hasAuth()
	{
	return method != null && method.kind != EtchGrammarConstants.TRUE;
	}

	/**
	* Checks the method to be called by authorize to make sure it is
	* a service method and that the parameters are correct.
	* @param service our service definition
	* @param msg the message being protected by the auth
	* @throws ParseException
	*/
	public void check( Service service, Message msg ) throws ParseException
	{
	if (!hasAuth())
	return;

	if (isMethodTrue() \|\| isMethodFalse())
	return;

	Named<?> named = service.get( method.image );
	if (named == null)
	throw new ParseException( String.format(
	"Authorize method name %s is not defined at %d",
	method.image, lineno() ) );

	if (!named.isMessage())
	throw new ParseException( String.format(
	"Authorize method name %s is not a method at %d",
	method.image, lineno() ) );

	Message authMsg = (Message) named;

	if (authMsg.type().type().kind != EtchGrammarConstants.BOOLEAN)
	throw new ParseException( String.format(
	"Authorize method %s result type is not boolean at %d",
	method.image, lineno() ) );

	List<Parameter> authParams = authMsg.getParameters();
	if (authParams.size() != argList.size())
	throw new ParseException( String.format(
	"Authorize method %s parameter list size does not match the number of supplied arguments at %d",
	method.image, lineno() ) );

	int n = argList.size();
	for (int i = 0; i < n; i++)
	{
	Parameter param = authParams.get( i );
	AuthArg aarg = argList.get( i );
	aarg.setType( param.type() );
	Token arg = aarg.value();

	// System.out.printf( "auth method %s param %s = %s\n",
	// method, param.name(), arg );

	switch (arg.kind)
	{
	case EtchGrammarConstants.NULL:
	// any parameter value may be specified as null...
	break;

	case EtchGrammarConstants.ID:
	// arg is referencing either a parameter of msg or a
	// service constant.
	checkMsgParamOrServiceConst( msg, param, arg, i );
	break;

	case EtchGrammarConstants.QID:
	// arg is referencing an enum item (enum.item) or
	// could be trying to reference a field of a
	// parameter of message (param(.field)+).
	checkMsgParamFieldRefOrEnumItem( msg, param, arg, i );
	break;

	case EtchGrammarConstants.TRUE:
	case EtchGrammarConstants.FALSE:
	// arg is a boolean constant the parameter better be
	// boolean, too.
	checkBooleanConstant( param, arg, i );
	break;

	case EtchGrammarConstants.INTEGER:
	// arg is an integer constant, the parameter better
	// be an integral or floating type and arg better
	// be the right size...
	checkIntegerConstant( param, arg, i );
	break;

	case EtchGrammarConstants.OCTAL:
	// arg is an octal constant, the parameter better
	// be an integral or floating type and arg better
	// be the right size...
	checkOctalConstant( param, arg, i );
	break;

	case EtchGrammarConstants.HEX:
	// arg is a hex constant, the parameter better
	// be an integral or floating type and arg better
	// be the right size...
	checkHexConstant( param, arg, i );
	break;

	case EtchGrammarConstants.BINARY:
	// arg is a binary constant, the parameter better
	// be an integral or floating type and arg better
	// be the right size...
	checkBinaryConstant( param, arg, i );
	break;

	case EtchGrammarConstants.DECIMAL:
	// arg is a decimal constant, the parameter better
	// be a floating type and arg better be the right
	// size...
	checkDecimalConstant( param, arg, i );
	break;

	case EtchGrammarConstants.STR:
	// arg is a string constant the parameter better be
	// string, too.
	checkStringConstant( param, arg, i );
	break;

	default:
	throw new ParseException( String.format(
	"Authorize method %s arg %d unsupported kind (%s) at line %d",
	method.image, i+1, arg, lineno() ) );
	}
	}
	}

	/**
	* @return true if the method is false.
	*/
	public boolean isMethodFalse()
	{
	// System.out.println( "isMethodFalse() => "+(method.kind == EtchGrammarConstants.FALSE) );
	return method.kind == EtchGrammarConstants.FALSE;
	}

	/**
	* @return true if the method is true.
	*/
	public boolean isMethodTrue()
	{
	return method.kind == EtchGrammarConstants.TRUE;
	}

	private void checkMsgParamOrServiceConst( Message msg, Parameter param,
	Token arg, int argNo ) throws ParseException
	{
	Parameter p = msg.getParameter( arg.image );
	if (p != null)
	{
	// it's a parameter, do the types match?

	Named<?> pt = p.type().getNamed( msg.parent() );
	Named<?> paramType = param.type().getNamed( msg.parent() );
	if (pt == paramType)
	return;

	throw typeMismatch( param, arg, argNo );
	}

	Named<?> named = msg.parent().get( arg.image );

	if (named != null)
	{
	// it's a named thing, it is a constant and do the
	// types match?

	if (named.isConstant())
	{
	Constant c = (Constant) named;

	// it's a constant, do the types match?

	Named<?> ct = c.type().getNamed( msg.parent() );
	Named<?> paramType = param.type().getNamed( msg.parent() );
	if (ct == paramType)
	return;

	throw typeMismatch( param, arg, argNo );
	}

	// the named thing is not a constant, so blow chunks.

	throw new ParseException( String.format(
	"Authorize method %s arg %d name not a parameter or constant (%s) at line %d",
	method.image, argNo+1, arg, lineno() ) );
	}

	// the named thing does not exist, so blow chunks.

	throw new ParseException( String.format(
	"Authorize method %s arg %d name unknown (%s) at line %d",
	method.image, argNo+1, arg, lineno() ) );
	}

	private void checkMsgParamFieldRefOrEnumItem( Message msg, Parameter param,
	Token arg, int argNo ) throws ParseException
	{
	Service service = msg.parent();

	StringTokenizer path = new StringTokenizer( arg.image, "." );
	String name = path.nextToken();

	Parameter p = msg.getParameter( name );
	if (p != null)
	{
	// it's a parameter, so type of p must be a struct...

	p = getField( service, p, path );

	if (p == null)
	throw new ParseException( String.format(
	"Authorize method %s arg %d name does not resolve to a field (%s) at line %d",
	method.image, argNo+1, arg, lineno() ) );

	Named<?> pt = p.type().getNamed( service );
	Named<?> paramType = param.type().getNamed( service );
	if (pt == paramType)
	return;

	throw typeMismatch( param, arg, argNo );
	}

	// it isn't a parameter, so it must be an enum...

	Named<?> named = service.get( name );
	if (named == null)
	throw new ParseException( String.format(
	"Authorize method %s arg %d name unknown (%s) at line %d",
	method.image, argNo+1, arg, lineno() ) );

	if (!named.isEnumx())
	throw new ParseException( String.format(
	"Authorize method %s arg %d name not a parameter field or enum (%s) at line %d",
	method.image, argNo+1, arg, lineno() ) );

	Enumx e = (Enumx) named;

	Item i = e.getItem( path.nextToken() );
	if (i == null)
	throw new ParseException( String.format(
	"Authorize method %s arg %d name not an enum item (%s) at line %d",
	method.image, argNo+1, arg, lineno() ) );

	if (path.hasMoreTokens())
	throw new ParseException( String.format(
	"Authorize method %s arg %d name not an enum item (%s) at line %d",
	method.image, argNo+1, arg, lineno() ) );
	}

	/**
	* @param service
	* @param p
	* @param path
	* @return the parameter that was resolved using the tokens from st.
	*/
	private Parameter getField( Service service, Parameter p, StringTokenizer path )
	{
	if (!path.hasMoreTokens())
	return p;

	String name = path.nextToken();

	// get the type of p, it better be a struct.

	Named<?> named = p.type().getNamed( service );
	if (named == null \|\| !named.isStruct())
	return null;

	Struct s = (Struct) named;

	p = s.getParameter( name );
	if (p == null)
	return null;

	return getField( service, p, path );
	}

	private void checkBooleanConstant( Parameter param, Token arg, int argNo )
	throws ParseException
	{
	if (!param.type().isBoolean())
	throw typeMismatch( param, arg, argNo );
	}

	private ParseException typeMismatch( Parameter param, Token arg, int argNo )
	{
	//if (true) throw new RuntimeException( "type mismatch" );
	return new ParseException( String.format(
	"Authorize method %s parameter %d (%s) type mismatch at line %d",
	method, argNo+1, param.name(), arg.beginLine ) );
	}

	private void checkIntegerConstant( Parameter param, Token arg, int argNo )
	throws ParseException
	{
	if (!(param.type().isIntegral() \|\| param.type().isFloating()))
	throw typeMismatch( param, arg, argNo );

	Long value = parseLong( arg.image, 10, "" );
	if (value != null)
	{
	// check range of long vs. integral or floating param type
	if (checkRange( value, param, arg, argNo ))
	return;
	}

	// value range is too much for long type, or parameter is not a
	// known integral or floating type; try double

	Double dvalue = parseDouble( arg.image );
	if (dvalue != null)
	{
	// check range of double vs. floating param type
	if (checkRange( dvalue, param, arg, argNo ))
	return;
	}

	// value range is too much for long or double type, or parameter
	// is not a known integral or floating type

	throw typeMismatch( param, arg, argNo );
	}

	private boolean checkRange( long value, Parameter param, Token arg,
	int argNo ) throws ParseException
	{
	// we parsed the value as a long, now see if it is compatible with
	// our parameter type.
	switch (param.type().type().kind)
	{
	case EtchGrammarConstants.BYTE:
	checkRange( value, Byte.MIN_VALUE, Byte.MAX_VALUE, param, arg,
	argNo );
	return true;

	case EtchGrammarConstants.SHORT:
	checkRange( value, Short.MIN_VALUE, Short.MAX_VALUE, param, arg,
	argNo );
	return true;

	case EtchGrammarConstants.INT:
	checkRange( value, Integer.MIN_VALUE, Integer.MAX_VALUE, param,
	arg, argNo );
	return true;

	case EtchGrammarConstants.LONG:
	case EtchGrammarConstants.FLOAT:
	case EtchGrammarConstants.DOUBLE:
	// value is a long, and that is certainly compatible with long,
	// float, or double.
	return true;

	default:
	// parameter is not a recognized type.
	return false;
	}
	}

	private boolean checkRange( double dvalue, Parameter param, Token arg,
	int argNo ) throws ParseException
	{
	// we parsed the value as a double, now see if it is compatible with
	// our parameter type.
	switch (param.type().type().kind)
	{
	case EtchGrammarConstants.FLOAT:
	checkRange( dvalue, Float.MIN_VALUE, Float.MAX_VALUE, param,
	arg, argNo );
	return true;

	case EtchGrammarConstants.DOUBLE:
	// value is a double, and that is certainly compatible with
	// double.
	return true;

	default:
	// parameter is not a recognized type.
	return false;
	}
	}

	private void checkRange( long value, long min, long max, Parameter param,
	Token arg, int argNo ) throws ParseException
	{
	if (value >= min && value <= max)
	return;

	throw new ParseException( String.format(
	"Authorize method %s parameter %d (%s) integral value out of range at line %d",
	method, argNo+1, param.name(), arg.beginLine ) );
	}

	private void checkRange( double dvalue, double min, double max,
	Parameter param, Token arg, int argNo ) throws ParseException
	{
	// ignore sign, it doesn't matter.

	dvalue = Math.abs( dvalue );

	if (dvalue >= min && dvalue <= max)
	return;

	throw new ParseException( String.format(
	"Authorize method %s parameter %d (%s) floating value out of range at line %d",
	method, argNo+1, param.name(), arg.beginLine ) );
	}

	private Long parseLong( String s, int radix, String prefix )
	{
	try
	{
	if (!s.toLowerCase().startsWith( prefix ))
	return null;
	return Long.parseLong( s.substring( prefix.length() ), radix );
	}
	catch ( NumberFormatException e )
	{
	return null;
	}
	}

	private Double parseDouble( String image )
	{
	try
	{
	return Double.parseDouble( image );
	}
	catch ( NumberFormatException e )
	{
	return null;
	}
	}

	private void checkOctalConstant( Parameter param, Token arg, int argNo )
	throws ParseException
	{
	if (!param.type().isIntegral())
	throw typeMismatch( param, arg, argNo );

	Long value = parseLong( arg.image, 8, "0" );
	if (value != null)
	{
	// check range of long vs. integral or floating param type
	if (checkRange( value, param, arg, argNo ))
	return;
	}

	// value range is too much for long or double type, or parameter
	// is not a known integral or floating type

	throw typeMismatch( param, arg, argNo );
	}

	private void checkHexConstant( Parameter param, Token arg, int argNo )
	throws ParseException
	{
	if (!param.type().isIntegral())
	throw typeMismatch( param, arg, argNo );

	Long value = parseLong( arg.image, 16, "0x" );
	if (value != null)
	{
	// check range of long vs. integral or floating param type
	if (checkRange( value, param, arg, argNo ))
	return;
	}

	// value range is too much for long or double type, or parameter
	// is not a known integral or floating type

	throw typeMismatch( param, arg, argNo );
	}

	private void checkBinaryConstant( Parameter param, Token arg, int argNo )
	throws ParseException
	{
	if (!param.type().isIntegral())
	throw typeMismatch( param, arg, argNo );

	Long value = parseLong( arg.image, 2, "0b" );
	if (value != null)
	{
	// check range of long vs. integral or floating param type
	if (checkRange( value, param, arg, argNo ))
	return;
	}

	// value range is too much for long or double type, or parameter
	// is not a known integral or floating type

	throw typeMismatch( param, arg, argNo );
	}

	private void checkDecimalConstant( Parameter param, Token arg, int argNo )
	throws ParseException
	{
	if (!param.type().isFloating())
	throw typeMismatch( param, arg, argNo );

	Double dvalue = parseDouble( arg.image );
	if (dvalue != null)
	{
	// check range of double vs. floating param type
	if (checkRange( dvalue, param, arg, argNo ))
	return;
	}

	// value range is too much for long or double type, or parameter
	// is not a known integral or floating type

	throw typeMismatch( param, arg, argNo );
	}

	private void checkStringConstant( Parameter param, Token arg, int argNo )
	throws ParseException
	{
	if (!param.type().isString())
	throw typeMismatch( param, arg, argNo );
	}

	/**
	* Wrapper for arg which holds the required arg type as well.
	*/
	public static class AuthArg
	{
	/**
	* @param arg
	*/
	public AuthArg( Token arg )
	{
	this.arg = arg;
	}

	private final Token arg;

	private TypeRef type;

	/**
	* @return the token of the arg.
	*/
	public Token value()
	{
	return arg;
	}

	/**
	* Sets the required type of the arg.
	* @param type
	*/
	public void setType( TypeRef type )
	{
	this.type = type;
	}

	/**
	* @return the required type of the arg.
	*/
	public TypeRef type()
	{
	return type;
	}

	/**
	* @return true if not an id or qid.
	*/
	public boolean isLiteralConstant()
	{
	switch (arg.kind)
	{
	case EtchGrammarConstants.TRUE:
	case EtchGrammarConstants.FALSE:
	case EtchGrammarConstants.INTEGER:
	case EtchGrammarConstants.OCTAL:
	case EtchGrammarConstants.HEX:
	case EtchGrammarConstants.BINARY:
	case EtchGrammarConstants.DECIMAL:
	case EtchGrammarConstants.STR:
	return true;
	default:
	return false;
	}
	}

	/**
	* @param msg
	* @return true if this names a parameter of the protected
	* method.
	*/
	public boolean isParameter( Message msg )
	{
	switch (arg.kind)
	{
	case EtchGrammarConstants.ID:
	return msg.hasParameter( arg.image );

	case EtchGrammarConstants.QID:
	{
	String[] n = StringUtil.leftSplit( arg.image, '.' );
	return msg.hasParameter( n[0] );
	}

	default:
	return false;
	}
	}

	/**
	* @param intf
	* @return true if this names a constant of the service.
	*/
	public boolean isConstant( Service intf )
	{
	if (arg.kind != EtchGrammarConstants.ID
	&& arg.kind != EtchGrammarConstants.QID)
	return false;

	Named<?> named = intf.get( arg.image );

	return named != null && named.isConstant();
	}

	/**
	* @param intf
	* @return true if this names an enum of the service.
	*/
	public boolean isEnum( Service intf )
	{
	if (arg.kind != EtchGrammarConstants.QID)
	return false;

	String[] n = StringUtil.leftSplit( arg.image, '.' );

	Named<?> named = intf.get( n[0] );

	return named != null && named.isEnumx();
	}
	}
	}