mcs/mbas/parameter.cs

   1 //
   2 // parameter.cs: Parameter definition.
   3 //
   4 // Author: Miguel de Icaza (miguel@gnu.org)
   5 //
   6 // Licensed under the terms of the GNU GPL
   7 //
   8 // (C) 2001 Ximian, Inc (http://www.ximian.com)
   9 //
  10 //
  11 //
  12 using System;
  13 using System.Reflection;
  14 using System.Reflection.Emit;
  15 using System.Collections;
  16
  17 namespace Mono.MonoBASIC {
  18
  19
  20         /// <summary>
  21         ///   Represents a single method parameter
  22         /// </summary>
  23         public class Parameter : Attributable {
  24                 [Flags]
  25                 public enum Modifier : byte {
  26                         NONE    = 0,
  27                         VAL     = 0,
  28                         REF     = 1,
  29                         OUT     = 2,
  30                         PARAMS  = 4,
  31                         // This is a flag which says that it's either REF or OUT.
  32                         ISBYREF = 8,
  33                         OPTIONAL = 16
  34                 }
  35
  36                 public readonly Expression TypeName;
  37                 public readonly Modifier ModFlags;
  38                 public readonly string Name;
  39                 public Type parameter_type;
  40                 public readonly Expression ParameterInitializer;
  41                 public readonly bool IsOptional;
  42
  43                 public Parameter (Expression type, string name, Modifier mod, Attributes attrs)
  44                         : base (attrs)
  45                 {
  46                         Name = name;
  47                         ModFlags = mod;
  48                         TypeName = type;
  49                         ParameterInitializer = null;
  50                         IsOptional = false;
  51                 }
  52
  53                 public Parameter (Expression type, string name, Modifier mod, Attributes attrs, Expression pi)
  54                         : base (attrs)
  55                 {
  56                         Name = name;
  57                         ModFlags = mod;
  58                         TypeName = type;
  59                         ParameterInitializer = pi;
  60                         IsOptional = false;
  61                 }
  62
  63                 public Parameter (Expression type, string name, Modifier mod, Attributes attrs, Expression pi, bool opt)
  64                         : base (attrs)
  65                 {
  66                         Name = name;
  67                         ModFlags = mod;
  68                         TypeName = type;
  69                         ParameterInitializer = pi;
  70                         IsOptional = opt;
  71                 }
  72
  73                 public override AttributeTargets AttributeTargets {
  74                         get {
  75                                 return AttributeTargets.Parameter;
  76                         }
  77                 }
  78
  79                 // <summary>
  80                 //   Resolve is used in method definitions
  81                 // </summary>
  82                 public bool Resolve (DeclSpace ds, Location l)
  83                 {
  84                         parameter_type = ds.ResolveType (TypeName, false, l);
  85
  86                         if (parameter_type == TypeManager.void_type){
  87                                 Report.Error (1536, l, "`void' parameter is not permitted");
  88                                 return false;
  89                         }
  90
  91                         return parameter_type != null;
  92                 }
  93
  94                 public Type ExternalType (DeclSpace ds, Location l)
  95                 {
  96                         if ((ModFlags & Parameter.Modifier.ISBYREF) != 0){
  97                                 string n = parameter_type.FullName + "&";
  98
  99                                 Type t = RootContext.LookupType (ds, n, false, l);
 100
 101                                 return t;
 102                         }
 103
 104                         return parameter_type;
 105                 }
 106
 107                 public Type ParameterType {
 108                         get {
 109                                 return parameter_type;
 110                         }
 111                 }
 112
 113                 public ParameterAttributes Attributes {
 114                         get {
 115                                 int flags = ((int) ModFlags) & ~((int) Parameter.Modifier.ISBYREF);
 116                                 switch ((Modifier) flags) {
 117                                 case Modifier.NONE:
 118                                         return ParameterAttributes.None;
 119                                 case Modifier.REF:
 120                                         return ParameterAttributes.None;
 121                                 case Modifier.OUT:
 122                                         return ParameterAttributes.Out;
 123                                 case Modifier.OPTIONAL:
 124                                         return ParameterAttributes.Optional;
 125                                 case Modifier.PARAMS:
 126                                         return 0;
 127                                 }
 128
 129                                 return ParameterAttributes.None;
 130                         }
 131                 }
 132
 133                 /// <summary>
 134                 ///   Returns the signature for this parameter evaluating it on the
 135                 ///   @tc context
 136                 /// </summary>
 137                 public string GetSignature (DeclSpace ds, Location loc)
 138                 {
 139                         if (parameter_type == null){
 140                                 if (!Resolve (ds, loc))
 141                                         return null;
 142                         }
 143
 144                         return ExternalType (ds, loc).FullName;
 145                 }
 146         }
 147
 148         /// <summary>
 149         ///   Represents the methods parameters
 150         /// </summary>
 151         public class Parameters {
 152                 public Parameter [] FixedParameters;
 153                 public readonly Parameter ArrayParameter;
 154                 string signature;
 155                 Type [] types;
 156                 Location loc;
 157
 158                 static Parameters empty_parameters;
 159
 160                 public Parameters (Parameter [] fixed_parameters, Parameter array_parameter, Location l)
 161                 {
 162                         FixedParameters = fixed_parameters;
 163                         ArrayParameter  = array_parameter;
 164                         loc = l;
 165                 }
 166
 167                 /// <summary>
 168                 ///   This is used to reuse a set of empty parameters, because they
 169                 ///   are common
 170                 /// </summary>
 171                 public static Parameters EmptyReadOnlyParameters {
 172                         get {
 173                                 if (empty_parameters == null)
 174                                         empty_parameters = new Parameters (null, null, Location.Null);
 175
 176                                 return empty_parameters;
 177                         }
 178                 }
 179
 180                 public bool HasOptional()
 181                 {
 182                         bool res = false;
 183
 184                         foreach (Parameter p in FixedParameters)
 185                         {
 186                                 if (p.IsOptional)
 187                                 {
 188                                         res = true;
 189                                         break;
 190                                 }
 191                         }
 192                         return (res);
 193                 }
 194
 195                 /// <summary>
 196                 ///   Returns the number of standard (i.e. non-optional) parameters
 197                 /// </summary>
 198                 public int CountStandardParams()
 199                 {
 200                         int res = 0;
 201                         if (FixedParameters == null)
 202                                 return 0;
 203
 204                         foreach (Parameter p in FixedParameters) {
 205                                 if (!p.IsOptional)
 206                                         res++;
 207                         }
 208                         return (res);
 209                 }
 210
 211                 /// <summary>
 212                 ///   Returns the number of optional parameters
 213                 /// </summary>
 214                 public int CountOptionalParams()
 215                 {
 216                         int res = 0;
 217                         if (FixedParameters == null)
 218                                 return 0;
 219
 220                         foreach (Parameter p in FixedParameters) {
 221                                 if (p.IsOptional)
 222                                         res++;
 223                         }
 224                         return (res);
 225                 }
 226
 227                 public Expression GetDefaultValue (int i)
 228                 {
 229                         Parameter p = FixedParameters[i];
 230                         if (p.IsOptional)
 231                                 return p.ParameterInitializer;
 232                         else
 233                                 return null;
 234                 }
 235
 236                 public void AppendParameter (Parameter p)
 237                 {
 238                         if (FixedParameters != null)
 239                         {
 240                                 Parameter [] pa = new Parameter [FixedParameters.Length+1];
 241                                 FixedParameters.CopyTo (pa, 0);
 242                                 pa[FixedParameters.Length] = p;
 243                                 FixedParameters = pa;
 244                         }
 245                         else
 246                         {
 247                                 FixedParameters = new Parameter [1];
 248                                 FixedParameters[0] = p;
 249                         }
 250                 }
 251
 252                 public void PrependParameter (Parameter p)
 253                 {
 254                         Parameter [] pa = new Parameter [FixedParameters.Length+1];
 255                         FixedParameters.CopyTo (pa, 1);
 256                         pa[0] = p;
 257                         FixedParameters = pa;
 258                 }
 259
 260                 public Parameters Copy (Location l)
 261                 {
 262                         Parameters p = new Parameters (null, null, l);
 263                         p.FixedParameters = new Parameter[this.FixedParameters.Length];
 264                         this.FixedParameters.CopyTo (p.FixedParameters, 0);
 265
 266                         return (p);
 267
 268                 }
 269
 270                 public bool Empty {
 271                         get {
 272                                 return (FixedParameters == null) && (ArrayParameter == null);
 273                         }
 274                 }
 275
 276                 public void ComputeSignature (DeclSpace ds)
 277                 {
 278                         signature = "";
 279                         if (FixedParameters != null){
 280                                 for (int i = 0; i < FixedParameters.Length; i++){
 281                                         Parameter par = FixedParameters [i];
 282
 283                                         signature += par.GetSignature (ds, loc);
 284                                 }
 285                         }
 286                         //
 287                         // Note: as per the spec, the `params' arguments (ArrayParameter)
 288                         // are not used in the signature computation for a method
 289                         //
 290                 }
 291
 292                 static void Error_DuplicateParameterName (string name)
 293                 {
 294                         Report.Error (
 295                                 100, "The parameter name `" + name + "' is a duplicate");
 296                 }
 297
 298                 public bool VerifyArgs ()
 299                 {
 300                         int count;
 301                         int i, j;
 302
 303                         if (FixedParameters == null)
 304                                 return true;
 305
 306                         count = FixedParameters.Length;
 307                         string array_par_name = ArrayParameter != null ? ArrayParameter.Name : null;
 308                         for (i = 0; i < count; i++){
 309                                 string base_name = FixedParameters [i].Name;
 310
 311                                 for (j = i + 1; j < count; j++){
 312                                         if (base_name != FixedParameters [j].Name)
 313                                                 continue;
 314                                         Error_DuplicateParameterName (base_name);
 315                                         return false;
 316                                 }
 317
 318                                 if (base_name == array_par_name){
 319                                         Error_DuplicateParameterName (base_name);
 320                                         return false;
 321                                 }
 322                         }
 323                         return true;
 324                 }
 325
 326                 /// <summary>
 327                 ///    Returns the signature of the Parameters evaluated in
 328                 ///    the @tc environment
 329                 /// </summary>
 330                 public string GetSignature (DeclSpace ds)
 331                 {
 332                         if (signature == null){
 333                                 VerifyArgs ();
 334                                 ComputeSignature (ds);
 335                         }
 336
 337                         return signature;
 338                 }
 339
 340                 /// <summary>
 341                 ///    Returns the paramenter information based on the name
 342                 /// </summary>
 343                 public Parameter GetParameterByName (string name, out int idx)
 344                 {
 345                         idx = 0;
 346                         int i = 0;
 347
 348                         if (FixedParameters != null){
 349                                 foreach (Parameter par in FixedParameters){
 350                                         if (par.Name == name){
 351                                                 idx = i;
 352                                                 return par;
 353                                         }
 354                                         i++;
 355                                 }
 356                         }
 357
 358                         if (ArrayParameter != null){
 359                                 if (name == ArrayParameter.Name){
 360                                         idx = i;
 361                                         return ArrayParameter;
 362                                 }
 363                         }
 364
 365                         return null;
 366                 }
 367
 368                 bool ComputeParameterTypes (DeclSpace ds)
 369                 {
 370                         int extra = (ArrayParameter != null) ? 1 : 0;
 371                         int i = 0;
 372                         int pc;
 373
 374                         if (FixedParameters == null)
 375                                 pc = extra;
 376                         else
 377                                 pc = extra + FixedParameters.Length;
 378
 379                         types = new Type [pc];
 380
 381                         if (!VerifyArgs ()){
 382                                 FixedParameters = null;
 383                                 return false;
 384                         }
 385
 386                         bool failed = false;
 387                         if (FixedParameters != null){
 388                                 foreach (Parameter p in FixedParameters){
 389                                         Type t = null;
 390
 391                                         if (p.Resolve (ds, loc))
 392                                                 t = p.ExternalType (ds, loc);
 393                                         else
 394                                                 failed = true;
 395
 396                                         types [i] = t;
 397                                         i++;
 398                                 }
 399                         }
 400
 401                         if (extra > 0){
 402                                 if (ArrayParameter.Resolve (ds, loc))
 403                                         types [i] = ArrayParameter.ExternalType (ds, loc);
 404                                 else
 405                                         failed = true;
 406                         }
 407
 408                         if (failed){
 409                                 types = null;
 410                                 return false;
 411                         }
 412
 413                         return true;
 414                 }
 415
 416                 //
 417                 // This variant is used by Delegates, because they need to
 418                 // resolve/define names, instead of the plain LookupType
 419                 //
 420                 public bool ComputeAndDefineParameterTypes (DeclSpace ds)
 421                 {
 422                         int extra = (ArrayParameter != null) ? 1 : 0;
 423                         int i = 0;
 424                         int pc;
 425
 426                         if (FixedParameters == null)
 427                                 pc = extra;
 428                         else
 429                                 pc = extra + FixedParameters.Length;
 430
 431                         types = new Type [pc];
 432
 433                         if (!VerifyArgs ()){
 434                                 FixedParameters = null;
 435                                 return false;
 436                         }
 437
 438                         bool ok_flag = true;
 439
 440                         if (FixedParameters != null){
 441                                 foreach (Parameter p in FixedParameters){
 442                                         Type t = null;
 443
 444                                         if (p.Resolve (ds, loc))
 445                                                 t = p.ExternalType (ds, loc);
 446                                         else
 447                                                 ok_flag = false;
 448
 449                                         types [i] = t;
 450                                         i++;
 451                                 }
 452                         }
 453
 454                         if (extra > 0){
 455                                 if (ArrayParameter.Resolve (ds, loc))
 456                                         types [i] = ArrayParameter.ExternalType (ds, loc);
 457                                 else
 458                                         ok_flag = false;
 459                         }
 460
 461                         //
 462                         // invalidate the cached types
 463                         //
 464                         if (!ok_flag){
 465                                 types = null;
 466                         }
 467
 468                         return ok_flag;
 469                 }
 470
 471                 /// <summary>
 472                 ///   Returns the argument types as an array
 473                 /// </summary>
 474                 static Type [] no_types = new Type [0];
 475
 476                 public Type [] GetParameterInfo (DeclSpace ds)
 477                 {
 478                         if (types != null)
 479                                 return types;
 480
 481                         if (FixedParameters == null && ArrayParameter == null)
 482                                 return no_types;
 483
 484                         if (ComputeParameterTypes (ds) == false){
 485                                 types = null;
 486                                 return null;
 487                         }
 488
 489                         return types;
 490                 }
 491
 492                 /// <summary>
 493                 ///   Returns the type of a given parameter, and stores in the `is_out'
 494                 ///   boolean whether this is an out or ref parameter.
 495                 ///
 496                 ///   Note that the returned type will not contain any dereference in this
 497                 ///   case (ie, you get "int" for a ref int instead of "int&"
 498                 /// </summary>
 499                 public Type GetParameterInfo (DeclSpace ds, int idx, out Parameter.Modifier mod)
 500                 {
 501                         mod = Parameter.Modifier.NONE;
 502
 503                         if (!VerifyArgs ()){
 504                                 FixedParameters = null;
 505                                 return null;
 506                         }
 507
 508                         if (FixedParameters == null && ArrayParameter == null)
 509                                 return null;
 510
 511                         if (types == null)
 512                                 if (ComputeParameterTypes (ds) == false)
 513                                         return null;
 514
 515                         //
 516                         // If this is a request for the variable lenght arg.
 517                         //
 518                         int array_idx = (FixedParameters != null ? FixedParameters.Length : 0);
 519                         if (idx == array_idx)
 520                                 return types [idx];
 521
 522                         //
 523                         // Otherwise, it is a fixed parameter
 524                         //
 525                         Parameter p = FixedParameters [idx];
 526                         mod = p.ModFlags;
 527
 528                         if ((mod & (Parameter.Modifier.REF | Parameter.Modifier.OUT)) != 0)
 529                                 mod |= Parameter.Modifier.ISBYREF;
 530
 531                         return p.ParameterType;
 532                 }
 533
 534                 public CallingConventions GetCallingConvention ()
 535                 {
 536                         // For now this is the only correc thing to do
 537                         return CallingConventions.Standard;
 538                 }
 539         }
 540 }