Lines Matching defs:the
337 operations are involved and required by the parser. RDIV_EXPR
339 once the type of both operator is worked out. */
360 /* The "StringBuffer" identifier used for the String `+' operator. */
2222 it under the terms of the GNU General Public License as published by
2223 the Free Software Foundation; either version 2, or (at your option)
2226 This program is distributed in the hope that it will be useful,
2227 but WITHOUT ANY WARRANTY; without even the implied warranty of
2228 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
2231 You should have received a copy of the GNU General Public License
2232 along with this program; if not, write to the Free Software
2238 This special exception was added by the Free Software Foundation
2241 /* This is the parser code that is written into each bison parser
2242 when the %semantic_parser declaration is not specified in the grammar.
2243 It was written by Richard Stallman by simplifying the hairy parser
2260 since that symbol is in the user namespace. */
2262 #if 0 /* No need for malloc.h, which pollutes the namespace;
2268 /* I don't know what this was needed for, but it pollutes the namespace.
2295 It is replaced by the list of actions, each action
2296 as one case of the switch. */
2306 This remains here temporarily to ease the
2307 transition to the new meaning of YYERROR, for GCC.
2346 /* If nonreentrant, generate the variables here */
2350 int yychar; /* the lookahead symbol */
2351 YYSTYPE yylval; /* the semantic value of the */
2355 YYLTYPE yylloc; /* location data for the lookahead */
2368 /* YYINITDEPTH indicates the initial size of the parser's stacks */
2374 /* YYMAXDEPTH is the maximum size the stacks can grow to
2375 (effective only if the built-in stack extension method is used). */
2386 /* Define __yy_memcpy. Note that the size argument
2387 should be passed with type unsigned int, because that is what the non-GCC
2396 /* This is the most reliable way to avoid incompatibilities
2414 /* This is the most reliable way to avoid incompatibilities
2433 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
2436 Grammar actions can access the variable by casting it
2437 to the proper pointer type. */
2472 short yyssa[YYINITDEPTH]; /* the state stack */
2473 YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */
2475 short *yyss = yyssa; /* refer to the stacks thru separate pointers */
2479 YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */
2500 YYSTYPE yyval; /* the variable used to return */
2501 /* semantic values from the action */
2518 so that they stay on the same level as the state stack.
2528 /* In all cases, when you get here, the value and location stacks
2529 have just been pushed. so pushing a state here evens the stacks. */
2536 /* Give user a chance to reallocate the stack */
2537 /* Use copies of these so that the &'s don't force the real ones into memory. */
2544 /* Get the current used size of the three stacks, in elements. */
2548 /* Each stack pointer address is followed by the size of
2549 the data in use in that stack, in bytes. */
2551 /* This used to be a conditional around just the two extra args,
2570 /* Extend the stack our own way. */
2626 /* Do appropriate processing given the current state. */
2670 /* Give the individual parser a way to print the precise meaning
2706 /* Shift the lookahead token. */
2713 /* Discard the token being shifted unless it is eof. */
2728 /* Do the default action for the current state. */
2735 /* Do a reduction. yyn is the number of a rule to reduce with. */
2739 yyval = yyvsp[1-yylen]; /* implement default value of the action */
2749 /* Print the symbols being reduced, and their result. */
3013 /* Store the location of the `}' when doing xrefs */
3023 /* Store the location of the `}' when doing xrefs */
3498 /* Store the location of the `}' when doing xrefs */
3517 /* Store the location of the `}' when doing xrefs */
3580 /* We know we have a statement, so set the debug
3690 I.e. make the last statment also have its own
3806 /* We have not condition, so we get rid of the EXIT_EXPR */
3831 /* We have not condition, so we get rid of the EXIT_EXPR */
3840 defined within the scope of the for loop */
3855 /* We now declare the loop body. The loop is
3860 /* The loop is added to the current block the for
3872 /* Init statement recorded within the previously
3880 /* Local variable are recorded within the previously
4042 declared initialized by the appropriate function
4236 /* If not initialized, allocate memory for the osb
4743 /* the action file gets copied in in place of this dollarsign */
4783 /* Now "shift" the result of the reduction.
4785 based on the state we popped back to
4786 and the rule number reduced by. */
4869 after shifting the error token. */
4875 yyerrdefault: /* current state does not do anything special for the error token. */
4884 yyerrpop: /* pop the current state because it cannot handle the error token */
4970 /* Flag for the error report routine to issue the error the first time
4971 it's called (overriding the default behavior which is to drop the
4972 first invocation and honor the second one, taking advantage of a
4976 /* Create a new parser context and make it the current one. */
4994 /* If the first file of a file list was a class file, no context
5051 /* Set the single import class file flag to 0 for the current list
5056 /* And restore those of the previous context */
5098 /* Save current error location but report latter, when the context is
5104 /* Do something to use the previous line if we're reaching the
5105 end of the file... */
5112 /* Ignore duplicate message on the same line. BTW, this is dubious. FIXME */
5143 the same line. This occurs when we report an error but don't have
5145 expression_statement is the only one to take care of. */
5261 /* Issue a missing return statement error. Uses METHOD to figure the
5262 last line of the method the error occurs in. */
5272 /* Issue an unreachable statement error. From NODE, find the next
5278 /* Browse node to find the next expression node that has a WFL. Use
5279 the location to report the error */
5389 /* Building the first dimension of a primitive type uses this
5397 /* Otherwise, if we have a WFL for this type, use it (the type
5403 /* Add all the dimensions */
5407 /* The type may have been incomplete in the first place */
5416 /* Build something that the type identifier resolver will identify as
5455 /* Should point out the one that don't fit. ASCII/unicode,
5492 - Can't already exists in the package */
5538 /* If DECL is NULL, create and push a new DECL, record the current
5548 /* Take care of the file and line business */
5550 /* If we're emiting xrefs, store the line/col number information */
5561 /* Link the declaration to the already seen ones */
5565 /* Create a new nodes in the global lists */
5587 the check operation is delayed until the super interface gets
5604 /* Create an interface in pass1 and return its decl. Return the
5625 - Can't use twice the same (checked in the modifier rule) */
5635 /* Set super info and mark the class a complete */
5669 - Public classes defined in the correct file */
5696 /* Set super info and mark the class a complete */
5703 /* If doing xref, store the location at which the inherited class
5708 /* Eventually sets the @deprecated tag flag */
5714 /* Can't use lookup_field () since we don't want to load the class and
5715 can't set the CLASS_LOADED_P flag */
5731 /* Wrap around lookup_field that doesn't potentially upset the value
5746 /* Find duplicate field within the same class declarations and report
5747 the error. Returns 1 if a duplicated field was found, 0
5764 /* The type may not have been completed by the time we report
5765 the error */
5784 declarations are linked to the undefined TYPE dependency list, to
5834 the variable specified more dimensions. Make sure we have
5836 change the name if we have an init. */
5849 /* Set lineno to the line the field was found and create a
5850 declaration for it. Eventually sets the @deprecated tag flag. */
5862 /* If we have an initialization value tied to the field */
5868 /* We include the field and its initialization part into
5882 to be processed at the time of the generation of <init>. */
5895 /* Generate the method $finit$ that initializes fields initialized
5923 /* Check whether it is necessary to generate a <clinit> for the class
5942 /* We process the list of assignment we produced as the result of
5943 the declaration of initialized static field and add them as
5944 statement to the <clinit> method. */
5947 /* We build the assignment expression that will initialize the
5958 /* Shared accros method_declarator and method_header to remember the
5959 patch stage that was reached during the declaration of the method.
5962 pending on the currently defined method. */
5966 /* Check the method declaration and add the method to its current
5967 class. If the argument list is known to contain incomplete types,
5968 the method is partially added and the registration will be resume
5969 once the method arguments resolved. If TYPE is NULL, we're dealing
6023 the method definition as a constructor, for the rest of this
6029 /* Method declared within the scope of an interface are implicitly
6035 /* If FLAGS isn't set because of a modifier, turn the
6037 the obsolete use of the modifier */
6050 unless we found an error identifier the constructor (in which
6051 case we retain the original name) */
6061 /* Do the returned type resolution and registration if necessary */
6079 /* When defining an abstract or interface method, the curly
6085 /* Remember the original argument list */
6092 /* Patch for the return type */
6098 /* This is the stop JDEP. METH allows the function's signature
6106 /* Fix the method argument list so we have the argument name
6110 /* Register the parameter number and re-install the current line
6115 /* Register exception specified by the `throws' keyword for
6116 resolution and set the method decl appropriate field to the list.
6117 Note: the grammar ensures that what we get here are class
6132 /* We set the DECL_NAME to ID so we can track the location where
6133 the function was declared. This allow us to report
6135 DECL_NAME is reinstalled properly (using the content of the
6138 reinstalled the same way. */
6142 /* Set the flag if we correctly processed a constructor */
6146 /* Eventually set the @deprecated tag flag */
6150 of the line number only. */
6175 /* Complete the method declaration with METHOD_BODY. */
6214 /* Merge last line of the function with first line, directly in the
6219 the next static block we'll see. */
6300 /* Check the methode header METH for abstract specifics features */
6321 /* Create a FUNCTION_TYPE node and start augmenting it with the
6323 are left as they are, but the returned node is marked as containing
6366 (wfl_name, "Variable `%s' is used more than once in the "
6373 to patch when the type get resolved, later. */
6414 /* From NAME, build a qualified identifier node using the
6415 qualification from the current package definition. */
6427 /* Called once the type a interface extends is resolved. Returns 0 if
6496 /* Create a new dependency list and link it (in a LIFO manner) to the
6523 /* Create a fake pointer based on the ID stored in
6559 dependency is inserted in the current type dependency list, in FIFO
6618 disrupting the current_class, input_file, lineno, etc, information
6619 about the class processed currently. */
6673 /* Process imports and reverse the import on demand list */
6678 /* Rever things so we have the right order */
6706 /* We do part of the job done in add_field */
6753 /* Recompute and reset the signature */
6801 /* Resolve class CLASS_TYPE. Handle the case of trying to resolve an
6833 /* 2- Resolve the bare type */
6838 /* 3- If we have and array, reconstruct the array down to its nesting */
6862 /* Effectively perform the resolution of class CLASS_TYPE. DECL or CL
6877 /* 1- Check for the type in single imports */
6881 /* 2- And check for the type in the current compilation unit. If it fails,
6882 try with a name qualified with the package name if appropriate. */
6928 /* 3- Check an other compilation unit that bears the name of type */
6937 /* 4- Check the import on demands. Don't allow bar.baz to be
6947 /* Resolve NAME and lay it out (if not done and if not the current
6949 called when type resolution is necessary during the walk pass. */
6958 /* Don't do that on the current class */
7060 (JDEP_WFL (dep), "Type `%s' not found in the declaration of the "
7068 (JDEP_WFL (dep), "Type `%s' not found in the declaration of the "
7082 (JDEP_WFL (dep), "Type `%s' not found in the declaration of the "
7107 /* Return a static string containing the DECL prototype string. If
7108 DECL is a constructor, use the class name instead of the form
7131 /* Reinstall the proper DECL_NAME on METHOD. Return 0 if the method
7140 /* NAME is just the plain name when Object is being defined */
7150 /* Return the name of METHOD_DECL, when DECL_NAME is a WFL */
7160 /* Explain here why METHOD_DECL doesn't have the DECL_CONSTRUCTUR_P
7163 /* Don't confuse method only bearing the name of their class as
7175 /* Track method being redefined inside the same class. As a side
7189 /* Reset the method name before running the check. If it returns 1,
7190 the method doesn't need to be verified with respect to method
7213 /* Check all the methods of CLASS. Methods are first completed then
7254 /* If we see one constructor a mark so we don't generate the
7263 /* We verify things thrown by the method. They must inherits from
7289 We set it temporarily for the sake of the error report. */
7293 /* Can't override a method with the same name and different return
7309 /* If the method has default, access in an other package, then
7310 issue a warning that the current method doesn't override the
7312 the match was found in java.lang.Object. */
7321 "override the corresponding method in class `%s', which is "
7362 - If the overriden or hidden method has default (package)
7363 access, then the overriding or hiding method must not be
7386 /* Inheriting multiple methods with the same signature. FIXME */
7391 aritifical method as the last entry. */
7403 (layout_class_methods), we prepare the its DECL
7408 /* If the class is declared PUBLIC, the default constructor is
7420 /* Return a non zero value if the `throws' clause of METHOD (if any)
7421 is incompatible with the `throws' clause of FOUND (if any). */
7472 /* 2- Check for double definition inside the defining interface */
7476 /* 3- Overriding is OK as far as we preserve the return type and
7477 the thrown exceptions (FIXME) */
7604 /* Return the line that matches DECL line number. Used during error
7625 /* Look for a simple name in the single-type import list */
7820 "the CLASSPATH environment variable and the access to the "
7835 /* Possibly find a type in the import on demands specified
7836 types. Returns 1 if an error occured, 0 otherwise. Run throught the
7881 /* Setup lineno so that it refers to the line of the import (in
7889 /* If there is no DECL set for the class or if the class isn't
7890 loaded and not seen in source yet, the load */
7909 /* The trick is to determine when the package name stops and were
7910 the name of something contained in the package starts. Then we
7932 /* Try the current package. */
8017 /* Access to a private class within the same package is
8046 /* Push a new block if statements were seen between the last time we
8076 hold the TYPE value if a new incomplete has to be created (as
8083 /* Go through all the declared variables */
8104 the variable specified more dimensions. Make sure we have
8114 /* If doing xreferencing, replace the line number with the WFL
8123 /* Add the initialization function to the current function's code */
8134 /* Setup dependency the type of the decl */
8158 /* New scope for the function */
8167 the decl to be patched later */
8211 /* Starts the body if an artifical method. */
8282 generated at all and we won't get warnings when using the -W
8306 /* FIXME: If the current method contains any exception handlers,
8313 /* Run the optimizers and output assembler code for this function. */
8323 /* Record EXPR in the current function block. Complements compound
8363 /* Hold THIS for the scope of the current public method decl. */
8388 /* Layout the methods of all classes loaded in one way on an
8389 other. Check methods of source parsed classes. Then reorder the
8390 fields and layout the classes or the type of all source parsed
8399 /* Layout the methods of all classes seen so far */
8404 /* Then check the methods of all parsed classes */
8414 /* Reverse the fields, but leave the dummy field in front.
8419 /* If the dummy field is there, reverse the right fields and
8420 just layout the type for proper fields offset */
8428 /* We don't have a dummy field, we need to layout the class,
8429 after having reversed the fields */
8441 /* From now on, the class is considered completely loaded */
8444 /* Error reported by the caller */
8449 /* We might have reloaded classes durign the process of laying out
8450 classes for code generation. We must layout the methods of those
8492 /* Prevent the use of `this' inside <clinit> */
8536 /* Now verify constructor circularity (stop after the first one
8544 /* Make the class data, register it and run the rest of decl
8559 the list of the catch clauses of the currently analysed try block. */
8585 /* Purge the `throws' list of unchecked exceptions. If we're
8586 doing xref, save a copy of the list and re-install it
8612 /* Don't go any further if we've found error(s) during the
8622 /* Pop the exceptions and sanity check */
8644 /* The constructor body must be crafted by hand. It's the
8645 constructor we defined when we realize we didn't have the
8650 /* It is an error for the compiler to generate a default
8651 constructor if the superclass doesn't have a constructor that
8701 /* Fix the constructor main block if we're adding extra stmts */
8711 /* Browse constructors in the super class, searching for a constructor
8760 java_expand_finals (); /* Expand and check the finals */
8769 chained to this hook. LOCATION contains the location of the
8780 with the way we're processing SUPER. A THIS from a primary as a
8829 /* Merge the two parts of a qualified name into LEFT. Set the
8830 location information of the resulting node to LOCATION, usually
8831 inherited from the location information of the `.' operator. */
8866 /* Extract the last identifier component of the qualified in WFL. The
8867 last identifier is removed from the linked list */
8886 /* Resolve the expression name NAME. Return its decl. */
8899 /* 15.13.1: NAME can appear within the scope of a local variable
8924 (id, "Can't reference `%s' before the superclass "
8929 /* Otherwise build what it takes to access the field */
8934 /* We may be asked to save the real field access node */
8973 We return something suitable to generate the field access. We also
8974 return the field decl in FIELD_DECL and its type in FIELD_TYPE. If
8990 /* Resolve the LENGTH field of an array here */
8999 case, the resolution is over and decl is the answer */
9026 /* If the static field was identified by an expression that
9027 needs to be generated, make the field access a compound
9028 expression whose first part is the evaluation of the
9051 /* If NODE is an access to f static field, strip out the class
9052 initialization part and return the field decl, otherwise, return
9098 /* If the access to the function call is a non static field,
9099 build the code to access it. */
9107 /* And code for the function call */
9118 /* If the previous call was static and this one is too,
9119 build a compound expression to hold the two (because in
9159 /* If the access to the function call is a non static field,
9160 build the code to access it. */
9167 /* And code for the array reference expression */
9175 /* Fix for -Wall Just go to the next statement. Don't
9183 /* It can be the keyword THIS */
9202 /* Check on the restricted use of SUPER */
9230 /* We wan't to be absolutely that the class is laid
9255 /* We have a type name. It's been already resolved when the
9311 /* We have to search for a field, knowing the type of its
9313 the last member of the expression as a type name, which
9314 means that for the resolution of this field, we'll look
9345 /* Layout the type of field_decl, since we may need
9378 declaration of the field when it is accessed from an
9399 /* We want to keep the location were found it, and the type
9404 /* This is the decl found and eventually the next one to
9432 /* Access granted if it occurs from within the package
9433 containing the class in which the protected member is
9438 /* If accessed with the form `super.member', then access is granted */
9442 /* Otherwise, access is granted if occuring from the class where
9450 occurs from within the class in witch it is declared */
9454 /* Default access are permitted only when occuring within the
9455 package in which the type (REFERENCE) is declared. In other words,
9456 REFERENCE is defined in the current package */
9470 /* Complain if the field is deprecated and the file it was defined
9471 in isn't compiled at the same time the file which contains its
9476 char the [20];
9480 strcpy (the, "method");
9483 strcpy (the, "field");
9486 strcpy (the, "class");
9493 the, lang_printable_name (decl, 0),
9498 /* Returns 1 if class was declared in the current package, 0 otherwise */
9513 /* If the current package is empty and the name of CLASS is
9514 qualified, class isn't in the current package. If there is a
9515 current package and the name of the CLASS is not qualified, class
9516 isn't in the current package */
9520 /* If there is not package and the name of CLASS isn't qualified,
9521 they belong to the same unnamed package */
9525 /* Compare the left part of the name of CLASS with the package name */
9551 and according to the situation, PRIMARY and WHERE may be
9552 used. IS_STATIC is set to 1 if the invoked function is static. */
9569 something fails, it should keep this value. It stop the
9571 MODIFY_EXPR: for the reasons why we sometimes want to keep on
9575 /* Since lookup functions are messing with line numbers, save the
9585 /* Extract the last IDENTIFIER of the qualified
9591 /* Given the context, IDENTIFIER is syntactically qualified
9639 /* Look the method up in the type selector. The method ought
9661 /* 1- Find the field to which the call applies */
9670 /* 2- Do the layout of the class where the last field
9681 /* 4- Add the field as an argument */
9719 /* Class to search is NULL if we're searching the current one */
9733 invoke it's constructor. It's use within the `new'
9749 /* This is a regular search in the local class, unless an
9758 in the class whose declaration contain the method being
9763 /* Don't continue if no method were found, as the next statement
9773 /* Non static methods are called with the current object extra
9774 argument. If patch a `new TYPE()', the argument is the value
9775 returned by the object allocator. If method is resolved as a
9776 primary, use the primary otherwise use the current THIS. */
9787 /* Check accessibility, position the is_static flag, build and
9788 return the call */
9807 /* In the context of an explicit constructor invocation, we can't
9809 invoking a static function, primary exists and is not the current
9817 (wfl, "Can't reference `this' before the superclass constructor has "
9824 /* Sometimes, we want the decl of the selected method. Such as for
9831 /* Generate the code used to initialize fields declared with an
9832 initialization statement. For now, it returns a call the the
9847 non static method. Return 1 if it's the case, 0 otherwise. */
9878 a new TYPE() type call, the first argument to the constructor
9879 isn't found in the incomming argument list, but delivered by
9928 returned value is the first argument to the constructor. We build
9929 a COMPOUND_EXPR and use saved expression so that the overall NEW
9985 /* Retrieve a refined list of matching methods. It covers the step
9998 /* Fix the arguments */
10011 /* Find all candidates and then refine the list, searching for the
10020 the sake of a better error report). */
10042 /* Issue the error message */
10106 /* We're done. Reset the searched interfaces list and finally search
10124 /* Either return the list obtained or all selected (but
10129 /* Effectively search for the approriate method in method */
10160 /* 15.11.2.2 Choose the Most Specific Method */
10192 /* Review the list and select the maximally specific methods */
10212 /* Make sure that the type of each M2_OR_ARGLIST arguments can be
10213 converted by method invocation conversion (5.3) to the type of the
10271 /* We first qualify the first element, then derive qualification of
10272 others based on the first one. If the first element is qualified
10273 by a resolution (field or type), this resolution is stored in the
10274 QUAL_RESOLUTION of the qual element being examined. We need to
10275 save the current_class since the use of SUPER might change the
10284 worked out to extract the part on which the qualification will
10344 /* If we have a THIS (from a primary), we set the context accordingly */
10355 /* If we have a SUPER, we set the context accordingly */
10360 return. The error will be caught later on, during the
10373 /* If name appears within the scope of a location variable
10375 name. We don't carry this test out if we're in the context of the
10383 /* If within the class/interface NAME was found to be used there
10395 - NAME is a class/interface declared within the compilation
10398 - NAME is declared in an another compilation unit of the package
10399 of the compilation unit containing NAME,
10401 of the compilation unit containing NAME. */
10415 type-import-on-demand declaration of the compilation unit
10422 /* Propagate the qualification accross other components of the
10433 /* Store the global qualification for the ambiguous part of ID back
10442 /* Restore the current class */
10535 Set the local values on decl names so we can identify them
10554 This makes it easier to scan the statements left-to-right
10555 without using recursion (which might overflow the stack
10556 if the block has many statements. */
10569 /* Now do the actual complete, without deep recursion for
10674 /* We don't complete operand 1, because it's the return value of
10675 the EXIT_BLOCK_EXPR which doesn't exist it Java */
10683 /* First, the case expression must be constant. Values of final
10702 /* It must be assignable to the type of the switch expression. */
10716 /* Multiple instance of a case label bearing the same
10745 /* Check whether the loop was enclosed in a labeled
10746 statement. If not, create one, insert the loop in it and
10747 return the node */
10750 /* Anyways, walk the body of the loop */
10753 /* Switch statement: walk the switch expression and the cases */
10763 inserted a label. Pop the label too. */
10847 disrupt the completion process. */
10872 /* Its important for the evaluation of assignment that
10873 this mark on the TREE_TYPE is propagated. */
10884 /* Patch all the dimensions */
10898 /* Setup the location of the current dimension, for
10905 /* They complete the array creation expression, if no errors
10962 /* Hand stablize the lhs on both places */
10966 /* Now complete the RHS. We write it back later on. */
10972 /* The last part of the rewrite for E1 op= E2 is to have
10973 E1 = (T)(E1 op E2), with T being the type of E1. */
10983 /* Otherwise we simply complete the RHS */
10990 /* Write back the RHS as we evaluated it. */
10994 produce a String out of the RHS (it might still be a
11027 /* Don't complete string nodes if dealing with the PLUS operand. */
11100 /* The first step in the re-write of qualified name handling. FIXME.
11137 (wfl_operator, "Can't reference `this' or `super' before the "
11147 and it's time to turn it into the appropriate String object
11178 crafted string buffer, as a result of use of the the String
11231 /* Link block B supercontext to the previous block. The current
11233 for the first time for a given function. The current function body
11260 /* Exit a block by changing the current function body
11261 (DECL_FUNCTION_BODY) to the current block super context, only if
11262 the block being exited isn't the method's top level one. */
11284 /* Lookup for NAME in the nested function's blocks, all the way up to
11285 the current toplevel one. It complies with Java's local variable
11324 /* This section of the source is reserved to build_* functions that
11325 are building incomplete tree nodes and the patch_* functions that
11329 we're currently dealing with the class java.lang.Object. */
11393 /* Build the corresponding binop if we deal with a Compound
11394 Assignment operator. Mark the binop sub-tree as part of a
11407 /* Print an INTEGER_CST node in a static buffer, and return the buffer. */
11445 (wfl, "Can't assign a value to the final variable `%s'",
11453 read. This is needed to avoid circularities in the implementation
11522 /* What we should do instead is resetting the all the flags
11537 /* 5.1 Try the assignment conversion for builtin type. */
11544 /* 15.25.2 If we have a compound assignment, convert RHS into the
11545 type of the LHS */
11557 /* If the assignment is part of a declaration, we use the WFL of
11558 the declared variable to point out the error and call it a
11559 declaration problem. If the assignment is a genuine =
11562 we use the WFL of the operator to indicate the error. */
11606 /* We need to retrieve the right argument for _Jv_CheckArrayStore */
11617 /* Build the invocation of _Jv_CheckArrayStore */
11642 /* Make sure the bound check will happen before the store check */
11658 /* Check that type SOURCE can be cast into type DEST. If the cast
11660 produce accurate error messages on the reasons why an assignment
11675 /* Try the reference assignment conversion */
11685 /* Check that RHS can be converted into LHS_TYPE by the assignment
11686 conversion (5.2), for the cases of RHS being a builtin type. Return
11687 NULL_TREE if the conversion fails or if because RHS isn't of a
11688 builtin type. Return a converted RHS if the conversion is possible. */
11711 - The value of the expression is representable in the type of the
11733 0 is the conversion test fails. This implements parts the method
11740 /* 5.1.1: This is the identity conversion part. */
11750 the < test below takes care of that */
11754 /* Accept all promoted type here. Note, we can't use <= in the test
11756 to char and the likes */
11765 than the precision of the LHS or if the LHS is a floating point
11766 type, or the RHS is a float and the RHS a double. */
11777 something of DEST type at runtime. Return 1 if the operation is
11778 valid, 0 otherwise. If CAST is set to 1, we're treating the case
11779 were SOURCE is cast into DEST, which borrows a lot of the
11805 /* If doing a cast and SOURCE is final, the operation is
11820 /* If not casting, DEST must be the Object type */
11833 with the same signature but different return type, then
11869 /* Can't cast an array to an interface unless the interface is
11911 converted to type DEST through the methond invocation conversion
11926 the method invocation conversion rule (5.3). */
11948 /* Store the location of the operator, for better error report. The
11949 string of the operator will be rebuild based on the OP value. */
11954 /* Build the string of the operator retained by NODE. If NODE is part
11955 of a compound expression, add an '=' at the end of the string. This
12009 errors but we modify NODE so that it contains the type computed
12010 according to the expression, when it's fixed. Otherwise, we write
12011 error_mark_node as the type. It allows us to further the analysis
12027 /* If 1, tell the routine that we have to return error_mark_node
12028 after checking for the initialization of the RHS */
12050 /* Change the division operator if necessary */
12055 function call to soft_fmod. Duplicate the value of the
12071 constant, a String object or a StringBuffer crafted for the
12072 purpose of the a previous usage of the String concatenation
12124 /* The type of the shift expression is the type of the promoted
12125 type of the left-hand operand */
12147 /* Copy the original value of the COMPOUND_ASSIGN_P flag */
12163 /* The first operand must be a reference type or the null type */
12179 /* If the first operand is null, the result is always false */
12203 /* There is no way the expression operand can be an instance of
12204 the type operand. This is a compile time error. */
12223 /* Binary numeric promotion is performed on both operand and the
12229 /* The type of the bitwise operator expression is BOOLEAN */
12239 /* Insert a break here if adding thing before the switch's
12260 /* The type of the conditional operators is BOOLEAN */
12269 /* The type of each of the operands must be a primitive numeric
12281 /* Binary numeric promotion is performed on the operands */
12283 /* The type of the relation expression is always BOOLEAN */
12291 /* Binary numeric promotion is performed on the operands */
12301 /* Types have to be either references or the null type. If
12303 type to the other by casting conversion. */
12312 what and report the error */
12351 /* Concatenate the STRING_CST CSTE and STRING. When AFTER is a non
12352 zero value, the value of CSTE comes after the valude of STRING */
12420 has to be a STRING_CST and the other part must be a STRING_CST or a
12421 INTEGRAL constant. Return a new STRING_CST if the operation
12424 If the case we want to optimize for space, we might want to return
12456 /* Implement the `+' operator. Does static optimization if possible,
12476 /* Discard empty strings on either side of the expression */
12491 /* If either one of the constant is null and the other non null
12514 /* OP1 is no longer the last node holding a crafted StringBuffer */
12521 /* Mark the last node holding a crafted StringBuffer */
12528 /* Patch the string node NODE. NODE can be a STRING_CST of a crafted
12545 /* Temporary disable forbid the use of `this'. */
12555 /* Build the internal representation of a string constant. */
12595 /* Store the location of the operator, for better error report. The
12596 string of the operator will be rebuild based on the OP value. */
12601 /* Special case for the ++/-- operators, since they require an extra
12603 later. IS_POST_P is 1 if the operator, 0 otherwise. */
12619 /* Store the location of the operator, for better error report. The
12620 string of the operator will be rebuild based on the OP value. */
12625 /* Build an incomplete cast operator, based on the use of the
12626 CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
12641 but preserve the type of NODE if the type is fixed. */
12692 valid wfl. We use wfl_op to locate errors related to the
12704 /* Before the addition, binary numeric promotion is performed on
12709 /* And write the promoted incremented and increment */
12712 /* Convert the overall back into its original type. */
12757 /* But the type is known. We will report an error if further
12771 /* If this cast is part of an assignment, we tell the code
12799 patching. Returned the resolved type or generate an error
12800 message. Return the resolved type or NULL_TREE. */
12849 /* float and double type are converted to the original type main
12850 variant and then to the target type. */
12855 to be worked out in gcc so we implement the extreme cases
12874 /* Now, the case can be determined correct at compile time if
12906 /* Build a null constant and give it the type TYPE. */
13022 /* Dimension types are verified. It's better for the types to be
13036 /* Each expression undergoes an unary numeric promotion (5.6.1) and the
13073 /* Set array_type to the actual (promoted) array type of the result. */
13093 differently according to the number of dimensions. If the number
13094 of dimension is equal to 1, then the nature of the base type
13099 /* Can't reuse what's already written in expr.c because it uses the
13192 /* Create a new type. We can't reuse the one we have here by
13203 /* Verify that one entry of the initializer element list can be
13204 assigned to the array base type. Report 1 if an error occurred, 0
13271 assigns the returned value to the RESULT_DECL that hold the value
13298 declared with the keyword void or that is a constructor */
13307 isn't declared with the keyword `void' */
13334 it. Note: at that point, the assignment is declared valid, but we
13341 /* If the function returned value and EXP are booleans, EXP has
13342 to be converted into the type of DECL_RESULT, which is integer
13420 LABELED_BLOCK_EXPR is created. No statement is attached to the
13445 parse_error_context (wfl_operator, "This is the location of the "
13466 /* In anyways, tie the loop to its statement */
13475 /* Create an empty LOOP_EXPR and make it the last in the nested loop
13488 /* Create a loop body according to the following structure:
13492 LABELED_BLOCK_EXPR the order is reversed for do loops)
13493 LABEL_DECL (a continue occuring here branches at the
13497 REVERSED, if non zero, tells that the loop condition expr comes
13498 after the body, like in the do-while loop.
13500 To obtain a loop, the loop body structure described above is
13504 LABEL_DECL (use this label to exit the loop)
13530 their order) on the current loop. Unlink the current loop from the
13544 /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
13557 loops feature the condition part */
13564 /* Put the condition and the loop body in place */
13566 /* LOOP is the current loop which has been now popped of the loop
13567 stack. Install the update block */
13572 /* If the loop isn't surrounded by a labeled statement, create one and
13626 break/continue. In this case, we make the target to be the
13627 label name, so that the error can be reported accuratly in
13631 /* Unlabeled break/continue will be handled during the
13653 /* Having an identifier here means that the target is unknown. */
13711 /* Encapsulate the break within a compound statement so that it's
13712 expanded all the times by expand_expr (and not clobered
13719 /* Process the exit expression belonging to a loop. Its type must be
13740 /* Now we know things are allright, invert the condition, fold and
13765 /* Complete the switch expression */
13768 /* The type of the switch expression must be char, byte, short or
13830 to process the next catch clause. We process the catch clause before
13831 the try block so that when processing the try block we can check thrown
13832 exceptions againts the caught type list. */
13839 /* At this point, the structure of the catch clause is
13841 BLOCK (with the decl of the parameter)
13843 MODIFY_EXPR (assignment of the catch parameter)
13851 but it's already enforced by the grammar. Make sure that the
13852 only parameter of the clause statement in of class Throwable
13856 /* Just make sure that the catch clause parameter type inherits
13872 the try statement such that the type of the catch
13873 clause's parameter is the same as or a subclass of the
13887 (wfl_operator, "`catch' not reached because of the catch "
13893 /* Complete the catch clause block */
13907 /* Things to do here: the exception must be thrown */
13909 /* Link this type to the caught type list */
13965 /* Generate a try-finally for the synchronized statement, except
13966 that the handler that catches all throw exception calls
13967 _Jv_MonitorExit and then rethrow the exception.
14018 /* If the thrown expression was a reference, we further the
14024 /* At least one of the following must be true */
14026 /* The type of the throw expression is a not checked exception,
14031 clause can receive the thrown expression or the current method is
14032 declared to throw such an exception. Or, the throw statement is
14033 contained in a method or constructor declaration and the type of
14034 the Expression is assignable to at least one type listed in the
14035 throws clause the declaration. */
14043 only if there is something after the list of checked
14044 exception thrown by the current function (if any). */
14047 "caught by any of the catch clause(s) "
14048 "of the surrounding `try' block",
14050 /* If we have no surrounding try statement and the method doesn't have
14053 /* We report that the exception can't be throw from a try block
14054 in all circumstances but when the `throw' is inside a static
14068 /* Otherwise, the current method doesn't have the appropriate
14081 /* If doing xrefs, keep the location where the `throw' was seen. */
14096 /* For all the unchecked exceptions thrown by DECL */
14109 "declared in the `throws' clause of `%s'",
14115 /* Return 1 if checked EXCEPTION is caught at the current nesting level of
14116 try-catch blocks, OR is listed in the `throws' clause of the
14125 /* First, all the nested try-catch-finally at that stage. The
14202 /* Determine the type of the conditional expression. Same types are
14210 /* if byte/short found, the resulting type is short */
14216 and t1's value fits in t2, then the resulting type is t2 */
14222 and t2's value fits in t1, then the resulting type is t1 */
14227 /* Otherwise, binary numeric promotion is applied and the
14228 resulting type is the promoted type of operand 1 and 2 */
14243 into the other one by assignment conversion, the latter
14244 determines the type of the expression */
14388 /* Wait until the USE_COMPONENT_REF re-write. FIXME. */