static void obj_coff_tag (int ignore ATTRIBUTE_UNUSED) { char *symbol_name; char name_end; if (def_symbol_in_progress == NULL) { as_warn (_(".tag pseudo-op used outside of .def/.endef ignored.")); demand_empty_rest_of_line (); return; } S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1); symbol_name = input_line_pointer; name_end = get_symbol_end (); #ifdef tc_canonicalize_symbol_name symbol_name = tc_canonicalize_symbol_name (symbol_name); #endif /* Assume that the symbol referred to by .tag is always defined. This was a bad assumption. I've added find_or_make. xoxorich. */ SA_SET_SYM_TAGNDX (def_symbol_in_progress, tag_find_or_make (symbol_name)); if (SA_GET_SYM_TAGNDX (def_symbol_in_progress) == 0L) as_warn (_("tag not found for .tag %s"), symbol_name); SF_SET_TAGGED (def_symbol_in_progress); *input_line_pointer = name_end; demand_empty_rest_of_line (); }
static void obj_coff_val (int ignore ATTRIBUTE_UNUSED) { if (def_symbol_in_progress == NULL) { as_warn (_(".val pseudo-op used outside of .def/.endef ignored.")); demand_empty_rest_of_line (); return; } if (is_name_beginner (*input_line_pointer)) { char *symbol_name = input_line_pointer; char name_end = get_symbol_end (); #ifdef tc_canonicalize_symbol_name symbol_name = tc_canonicalize_symbol_name (symbol_name); #endif if (streq (symbol_name, ".")) { /* If the .val is != from the .def (e.g. statics). */ symbol_set_frag (def_symbol_in_progress, frag_now); S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ()); } else if (! streq (S_GET_NAME (def_symbol_in_progress), symbol_name)) { expressionS exp; exp.X_op = O_symbol; exp.X_add_symbol = symbol_find_or_make (symbol_name); exp.X_op_symbol = NULL; exp.X_add_number = 0; symbol_set_value_expression (def_symbol_in_progress, &exp); /* If the segment is undefined when the forward reference is resolved, then copy the segment id from the forward symbol. */ SF_SET_GET_SEGMENT (def_symbol_in_progress); /* FIXME: gcc can generate address expressions here in unusual cases (search for "obscure" in sdbout.c). We just ignore the offset here, thus generating incorrect debugging information. We ignore the rest of the line just below. */ } /* Otherwise, it is the name of a non debug symbol and its value will be calculated later. */ *input_line_pointer = name_end; } else { S_SET_VALUE (def_symbol_in_progress, get_absolute_expression ()); } demand_empty_rest_of_line (); }
static void obj_coff_scl (int ignore ATTRIBUTE_UNUSED) { if (def_symbol_in_progress == NULL) { as_warn (_(".scl pseudo-op used outside of .def/.endef ignored.")); demand_empty_rest_of_line (); return; } S_SET_STORAGE_CLASS (def_symbol_in_progress, get_absolute_expression ()); demand_empty_rest_of_line (); }
static void obj_coff_size (int ignore ATTRIBUTE_UNUSED) { if (def_symbol_in_progress == NULL) { as_warn (_(".size pseudo-op used outside of .def/.endef ignored.")); demand_empty_rest_of_line (); return; } S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1); SA_SET_SYM_SIZE (def_symbol_in_progress, get_absolute_expression ()); demand_empty_rest_of_line (); }
static void obj_coff_line (int ignore ATTRIBUTE_UNUSED) { int this_base; if (def_symbol_in_progress == NULL) { /* Probably stabs-style line? */ obj_coff_ln (0); return; } this_base = get_absolute_expression (); if (streq (".bf", S_GET_NAME (def_symbol_in_progress))) coff_line_base = this_base; S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1); SA_SET_SYM_LNNO (def_symbol_in_progress, this_base); demand_empty_rest_of_line (); #ifndef NO_LISTING if (streq (".bf", S_GET_NAME (def_symbol_in_progress))) { extern int listing; if (listing) listing_source_line ((unsigned int) this_base); } #endif }
void s_endif (int arg ATTRIBUTE_UNUSED) { struct conditional_frame *hold; if (current_cframe == NULL) { as_bad (_("\".endif\" without \".if\"")); } else { if (LISTING_SKIP_COND () && current_cframe->ignoring && (current_cframe->previous_cframe == NULL || ! current_cframe->previous_cframe->ignoring)) listing_list (1); hold = current_cframe; current_cframe = current_cframe->previous_cframe; obstack_free (&cond_obstack, hold); } /* if one pop too many */ if (flag_mri) { while (! is_end_of_line[(unsigned char) *input_line_pointer]) ++input_line_pointer; } demand_empty_rest_of_line (); }
static void obj_mach_o_weak (int ignore ATTRIBUTE_UNUSED) { char *name; int c; symbolS *symbolP; do { /* Get symbol name. */ name = input_line_pointer; c = get_symbol_end (); symbolP = symbol_find_or_make (name); S_SET_WEAK (symbolP); *input_line_pointer = c; SKIP_WHITESPACE (); if (c != ',') break; input_line_pointer++; SKIP_WHITESPACE (); } while (*input_line_pointer != '\n'); demand_empty_rest_of_line (); }
static void s_data1() { subseg_new(SEG_DATA, 1); demand_empty_rest_of_line(); return; }
static void s_atmp() { register int temp; if (strncmp(input_line_pointer, "sp", 2) == 0) { input_line_pointer += 2; atmp = 2; } else if (strncmp(input_line_pointer, "fp", 2) == 0) { input_line_pointer += 2; atmp = 3; } else if (strncmp(input_line_pointer, "r", 1) == 0) { input_line_pointer += 1; temp = get_absolute_expression(); if (temp >= 0 && temp <= 31) atmp = temp; else as_warn("Unknown temporary pseudo register"); } else { as_warn("Unknown temporary pseudo register"); } demand_empty_rest_of_line(); return; }
char * dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED) { offsetT num; char *filename; int filename_len; /* Continue to accept a bare string and pass it off. */ SKIP_WHITESPACE (); if (*input_line_pointer == '"') { s_app_file (0); return NULL; } num = get_absolute_expression (); filename = demand_copy_C_string (&filename_len); demand_empty_rest_of_line (); if (num < 1) { as_bad (_("file number less than one")); return NULL; } if (num < (int) files_in_use && files[num].filename != 0) { as_bad (_("file number %ld already allocated"), (long) num); return NULL; } get_filenum (filename, num); return filename; }
static void s_common() { register char *name; register char c; register char *p; register int temp; register symbolS * symbolP; name = input_line_pointer; c = get_symbol_end(); /* just after name is now '\0' */ p = input_line_pointer; *p = c; SKIP_WHITESPACE(); if ( * input_line_pointer != ',' ) { as_warn("Expected comma after symbol-name"); ignore_rest_of_line(); return; } input_line_pointer ++; /* skip ',' */ if ( (temp = get_absolute_expression ()) < 0 ) { as_warn(".COMMon length (%d.) <0! Ignored.", temp); ignore_rest_of_line(); return; } *p = 0; symbolP = symbol_find_or_make (name); *p = c; if ( (symbolP->sy_type & N_TYPE) != N_UNDF || symbolP->sy_other != 0 || symbolP->sy_desc != 0) { as_warn( "Ignoring attempt to re-define symbol"); ignore_rest_of_line(); return; } if (symbolP->sy_value) { if (symbolP->sy_value != temp) { as_warn( "Length of .comm \"%s\" is already %d. Not changed to %d.", symbolP->sy_name, symbolP->sy_value, temp); } } else { symbolP->sy_value = temp; symbolP->sy_type |= N_EXT; } know(symbolP->sy_frag == &zero_address_frag); if (strncmp(input_line_pointer, ",\"bss\"", 6) != 0) { p=input_line_pointer; while(*p && *p!='\n') p++; c= *p; *p='\0'; as_warn("bad .common segment: `%s'", input_line_pointer); *p=c; return; } input_line_pointer += 6; demand_empty_rest_of_line(); return; }
void s_if (int arg) { expressionS operand; struct conditional_frame cframe; int t; char *stop = NULL; char stopc; if (flag_mri) stop = mri_comment_field (&stopc); /* Leading whitespace is part of operand. */ SKIP_WHITESPACE (); if (current_cframe != NULL && current_cframe->ignoring) { operand.X_add_number = 0; while (! is_end_of_line[(unsigned char) *input_line_pointer]) ++input_line_pointer; } else { expression (&operand); if (operand.X_op != O_constant) as_bad (_("non-constant expression in \".if\" statement")); } switch ((operatorT) arg) { case O_eq: t = operand.X_add_number == 0; break; case O_ne: t = operand.X_add_number != 0; break; case O_lt: t = operand.X_add_number < 0; break; case O_le: t = operand.X_add_number <= 0; break; case O_ge: t = operand.X_add_number >= 0; break; case O_gt: t = operand.X_add_number > 0; break; default: abort (); return; } /* If the above error is signaled, this will dispatch using an undefined result. No big deal. */ initialize_cframe (&cframe); cframe.ignoring = cframe.dead_tree || ! t; current_cframe = ((struct conditional_frame *) obstack_copy (&cond_obstack, &cframe, sizeof (cframe))); if (LISTING_SKIP_COND () && cframe.ignoring && (cframe.previous_cframe == NULL || ! cframe.previous_cframe->ignoring)) listing_list (2); if (flag_mri) mri_comment_end (stop, stopc); demand_empty_rest_of_line (); }
void s_ifdef (int test_defined) { /* Points to name of symbol. */ char *name; /* Points to symbol. */ symbolS *symbolP; struct conditional_frame cframe; char c; /* Leading whitespace is part of operand. */ SKIP_WHITESPACE (); name = input_line_pointer; if (!is_name_beginner (*name)) { as_bad (_("invalid identifier for \".ifdef\"")); obstack_1grow (&cond_obstack, 0); ignore_rest_of_line (); return; } c = get_symbol_end (); symbolP = symbol_find (name); *input_line_pointer = c; initialize_cframe (&cframe); if (cframe.dead_tree) cframe.ignoring = 1; else { int is_defined; /* Use the same definition of 'defined' as .equiv so that a symbol which has been referenced but not yet given a value/address is considered to be undefined. */ is_defined = symbolP != NULL && S_IS_DEFINED (symbolP) && S_GET_SEGMENT (symbolP) != reg_section; cframe.ignoring = ! (test_defined ^ is_defined); } current_cframe = ((struct conditional_frame *) obstack_copy (&cond_obstack, &cframe, sizeof (cframe))); if (LISTING_SKIP_COND () && cframe.ignoring && (cframe.previous_cframe == NULL || ! cframe.previous_cframe->ignoring)) listing_list (2); demand_empty_rest_of_line (); }
static void obj_coff_type (int ignore ATTRIBUTE_UNUSED) { if (def_symbol_in_progress == NULL) { as_warn (_(".type pseudo-op used outside of .def/.endef ignored.")); demand_empty_rest_of_line (); return; } S_SET_DATA_TYPE (def_symbol_in_progress, get_absolute_expression ()); if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress)) && S_GET_STORAGE_CLASS (def_symbol_in_progress) != C_TPDEF) SF_SET_FUNCTION (def_symbol_in_progress); demand_empty_rest_of_line (); }
static void obj_coff_loc (int ignore ATTRIBUTE_UNUSED) { int lineno; /* FIXME: Why do we need this check? We need it for ECOFF, but why do we need it for COFF? */ if (now_seg != text_section) { as_warn (_(".loc outside of .text")); demand_empty_rest_of_line (); return; } if (def_symbol_in_progress != NULL) { as_warn (_(".loc pseudo-op inside .def/.endef: ignored.")); demand_empty_rest_of_line (); return; } /* Skip the file number. */ SKIP_WHITESPACE (); get_absolute_expression (); SKIP_WHITESPACE (); lineno = get_absolute_expression (); #ifndef NO_LISTING { extern int listing; if (listing) { lineno += coff_line_base - 1; listing_source_line (lineno); } } #endif demand_empty_rest_of_line (); add_lineno (frag_now, frag_now_fix (), lineno); }
void dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED) { offsetT filenum, line, column; filenum = get_absolute_expression (); SKIP_WHITESPACE (); line = get_absolute_expression (); SKIP_WHITESPACE (); column = get_absolute_expression (); demand_empty_rest_of_line (); if (filenum < 1) { as_bad (_("file number less than one")); return; } if (filenum >= (int) files_in_use || files[filenum].filename == 0) { as_bad (_("unassigned file number %ld"), (long) filenum); return; } current.filenum = filenum; current.line = line; current.column = column; current.flags = DWARF2_FLAG_BEGIN_STMT; loc_directive_seen = TRUE; #ifndef NO_LISTING if (listing) { if (files[filenum].dir) { size_t dir_len = strlen (dirs[files[filenum].dir]); size_t file_len = strlen (files[filenum].filename); char *cp = (char *) alloca (dir_len + 1 + file_len + 1); memcpy (cp, dirs[files[filenum].dir], dir_len); cp[dir_len] = '/'; memcpy (cp + dir_len + 1, files[filenum].filename, file_len); cp[dir_len + file_len + 1] = '\0'; listing_source_file (cp); } else listing_source_file (files[filenum].filename); listing_source_line (line); } #endif }
static void obj_coff_def (int what ATTRIBUTE_UNUSED) { char name_end; /* Char after the end of name. */ char *symbol_name; /* Name of the debug symbol. */ char *symbol_name_copy; /* Temporary copy of the name. */ unsigned int symbol_name_length; if (def_symbol_in_progress != NULL) { as_warn (_(".def pseudo-op used inside of .def/.endef: ignored.")); demand_empty_rest_of_line (); return; } SKIP_WHITESPACES (); symbol_name = input_line_pointer; name_end = get_symbol_end (); symbol_name_length = strlen (symbol_name); symbol_name_copy = xmalloc (symbol_name_length + 1); strcpy (symbol_name_copy, symbol_name); #ifdef tc_canonicalize_symbol_name symbol_name_copy = tc_canonicalize_symbol_name (symbol_name_copy); #endif /* Initialize the new symbol. */ def_symbol_in_progress = symbol_make (symbol_name_copy); symbol_set_frag (def_symbol_in_progress, &zero_address_frag); S_SET_VALUE (def_symbol_in_progress, 0); if (S_IS_STRING (def_symbol_in_progress)) SF_SET_STRING (def_symbol_in_progress); *input_line_pointer = name_end; demand_empty_rest_of_line (); }
static void obj_coff_dim (int ignore ATTRIBUTE_UNUSED) { int dim_index; if (def_symbol_in_progress == NULL) { as_warn (_(".dim pseudo-op used outside of .def/.endef: ignored.")); demand_empty_rest_of_line (); return; } S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1); for (dim_index = 0; dim_index < DIMNUM; dim_index++) { SKIP_WHITESPACES (); SA_SET_SYM_DIMEN (def_symbol_in_progress, dim_index, get_absolute_expression ()); switch (*input_line_pointer) { case ',': input_line_pointer++; break; default: as_warn (_("badly formed .dim directive ignored")); /* Fall through. */ case '\n': case ';': dim_index = DIMNUM; break; } } demand_empty_rest_of_line (); }
static void dot_cfi_endproc (int ignored ATTRIBUTE_UNUSED) { if (frchain_now->frch_cfi_data == NULL) { as_bad (_(".cfi_endproc without corresponding .cfi_startproc")); ignore_rest_of_line (); return; } cfi_end_fde (symbol_temp_new_now ()); demand_empty_rest_of_line (); }
/* * sort of like s_lcomm * */ static void s_reserve() { char *name; char c; char *p; int temp; symbolS *symbolP; name = input_line_pointer; c = get_symbol_end(); p = input_line_pointer; *p = c; SKIP_WHITESPACE(); if ( * input_line_pointer != ',' ) { as_warn("Expected comma after name"); ignore_rest_of_line(); return; } input_line_pointer ++; if ((temp = get_absolute_expression()) < 0) { as_warn("BSS length (%d.) <0! Ignored.", temp); ignore_rest_of_line(); return; } *p = 0; symbolP = symbol_find_or_make(name); *p = c; if (strncmp(input_line_pointer, ",\"bss\"", 6) != 0) { as_warn("bad .reserve segment: `%s'", input_line_pointer); return; } input_line_pointer += 6; if (symbolP->sy_other == 0 && symbolP->sy_desc == 0 && ((symbolP->sy_type == N_BSS && symbolP->sy_value == local_bss_counter) || ((symbolP->sy_type & N_TYPE) == N_UNDF && symbolP->sy_value == 0))) { symbolP->sy_value = local_bss_counter; symbolP->sy_type = N_BSS; symbolP->sy_frag = & bss_address_frag; local_bss_counter += temp; } else { as_warn( "Ignoring attempt to re-define symbol from %d. to %d.", symbolP->sy_value, local_bss_counter ); } demand_empty_rest_of_line(); return; }
static void dot_cfi_sections (int ignored ATTRIBUTE_UNUSED) { int sections = 0; SKIP_WHITESPACE (); if (is_name_beginner (*input_line_pointer)) while (1) { char *name, c; name = input_line_pointer; c = get_symbol_end (); if (strncmp (name, ".eh_frame", sizeof ".eh_frame") == 0 && name[9] != '_') sections |= CFI_EMIT_eh_frame; else if (strncmp (name, ".debug_frame", sizeof ".debug_frame") == 0) sections |= CFI_EMIT_debug_frame; #ifdef tc_cfi_section_name else if (strcmp (name, tc_cfi_section_name) == 0) sections |= CFI_EMIT_target; #endif else { *input_line_pointer = c; input_line_pointer = name; break; } *input_line_pointer = c; SKIP_WHITESPACE (); if (*input_line_pointer == ',') { name = input_line_pointer++; SKIP_WHITESPACE (); if (!is_name_beginner (*input_line_pointer)) { input_line_pointer = name; break; } } else if (is_name_beginner (*input_line_pointer)) break; } demand_empty_rest_of_line (); cfi_sections = sections; }
static void obj_coff_ln (int appline) { int l; if (! appline && def_symbol_in_progress != NULL) { as_warn (_(".ln pseudo-op inside .def/.endef: ignored.")); demand_empty_rest_of_line (); return; } l = get_absolute_expression (); /* If there is no lineno symbol, treat a .ln directive as if it were a .appline directive. */ if (appline || current_lineno_sym == NULL) new_logical_line ((char *) NULL, l - 1); else add_lineno (frag_now, frag_now_fix (), l); #ifndef NO_LISTING { extern int listing; if (listing) { if (! appline) l += coff_line_base - 1; listing_source_line (l); } } #endif demand_empty_rest_of_line (); }
void dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED) { offsetT value = get_absolute_expression (); if (value != 0 && value != 1) { as_bad (_("expected 0 or 1")); ignore_rest_of_line (); } else { dwarf2_loc_mark_labels = value != 0; demand_empty_rest_of_line (); } }
void s_else (int arg ATTRIBUTE_UNUSED) { if (current_cframe == NULL) { as_bad (_("\".else\" without matching \".if\"")); } else if (current_cframe->else_seen) { as_bad (_("duplicate \"else\"")); as_bad_where (current_cframe->else_file_line.file, current_cframe->else_file_line.line, _("here is the previous \"else\"")); as_bad_where (current_cframe->if_file_line.file, current_cframe->if_file_line.line, _("here is the previous \"if\"")); } else { as_where (¤t_cframe->else_file_line.file, ¤t_cframe->else_file_line.line); current_cframe->ignoring = current_cframe->dead_tree | !current_cframe->ignoring; if (LISTING_SKIP_COND () && (current_cframe->previous_cframe == NULL || ! current_cframe->previous_cframe->ignoring)) { if (! current_cframe->ignoring) listing_list (1); else listing_list (2); } current_cframe->else_seen = 1; } if (flag_mri) { while (! is_end_of_line[(unsigned char) *input_line_pointer]) ++input_line_pointer; } demand_empty_rest_of_line (); }
char * dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED) { offsetT num; char *filename; int filename_len; /* Continue to accept a bare string and pass it off. */ SKIP_WHITESPACE (); if (*input_line_pointer == '"') { s_app_file (0); return NULL; } num = get_absolute_expression (); filename = demand_copy_C_string (&filename_len); if (filename == NULL) return NULL; demand_empty_rest_of_line (); if (num < 1) { as_bad (_("file number less than one")); return NULL; } /* A .file directive implies compiler generated debug information is being supplied. Turn off gas generated debug info. */ debug_type = DEBUG_NONE; if (num < (int) files_in_use && files[num].filename != 0) { as_bad (_("file number %ld already allocated"), (long) num); return NULL; } get_filenum (filename, num); return filename; }
static void dot_cfi_endproc (int ignored ATTRIBUTE_UNUSED) { struct fde_entry *fde; if (frchain_now->frch_cfi_data == NULL) { as_bad (_(".cfi_endproc without corresponding .cfi_startproc")); ignore_rest_of_line (); return; } fde = frchain_now->frch_cfi_data->cur_fde_data; cfi_end_fde (symbol_temp_new_now ()); demand_empty_rest_of_line (); if ((cfi_sections & CFI_EMIT_target) != 0) tc_cfi_endproc (fde); }
void s_ifc (int arg) { char *stop = NULL; char stopc; char *s1, *s2; int len1, len2; int res; struct conditional_frame cframe; if (flag_mri) stop = mri_comment_field (&stopc); s1 = get_mri_string (',', &len1); if (*input_line_pointer != ',') as_bad (_("bad format for ifc or ifnc")); else ++input_line_pointer; s2 = get_mri_string (';', &len2); res = len1 == len2 && strncmp (s1, s2, len1) == 0; initialize_cframe (&cframe); cframe.ignoring = cframe.dead_tree || ! (res ^ arg); current_cframe = ((struct conditional_frame *) obstack_copy (&cond_obstack, &cframe, sizeof (cframe))); if (LISTING_SKIP_COND () && cframe.ignoring && (cframe.previous_cframe == NULL || ! cframe.previous_cframe->ignoring)) listing_list (2); if (flag_mri) mri_comment_end (stop, stopc); demand_empty_rest_of_line (); }
static void dot_cfi_startproc (int ignored ATTRIBUTE_UNUSED) { int simple = 0; if (frchain_now->frch_cfi_data != NULL) { as_bad (_("previous CFI entry not closed (missing .cfi_endproc)")); ignore_rest_of_line (); return; } cfi_new_fde (symbol_temp_new_now ()); SKIP_WHITESPACE (); if (is_name_beginner (*input_line_pointer)) { char *name, c; name = input_line_pointer; c = get_symbol_end (); if (strcmp (name, "simple") == 0) { simple = 1; *input_line_pointer = c; } else input_line_pointer = name; } demand_empty_rest_of_line (); frchain_now->frch_cfi_data->cur_cfa_offset = 0; if (!simple) tc_cfi_frame_initial_instructions (); if ((cfi_sections & CFI_EMIT_target) != 0) tc_cfi_startproc (); }
static void s_sparc_align() { register unsigned int temp; register long int temp_fill; unsigned int i; temp = get_absolute_expression (); #define MAX_ALIGNMENT (1 << 15) if ( temp > MAX_ALIGNMENT ) { as_warn("Alignment too large: %d. assumed.", temp = MAX_ALIGNMENT); } /* * For the sparc, `.align (1<<n)' actually means `.align n' * so we have to convert it. */ if (temp != 0) { for (i = 0; (temp & 1) == 0; temp >>= 1, ++i) ; } if (temp != 1) { as_warn("Alignment not a power of 2"); } temp = i; if (*input_line_pointer == ',') { input_line_pointer ++; temp_fill = get_absolute_expression (); } else { temp_fill = 0; } /* Only make a frag if we HAVE to. . . */ if (temp && ! need_pass_2) { frag_align (temp, (int)temp_fill); } demand_empty_rest_of_line(); return; }
static void s_seg() { if (strncmp(input_line_pointer, "\"text\"", 6) == 0) { input_line_pointer += 6; s_text(); return; } if (strncmp(input_line_pointer, "\"data\"", 6) == 0) { input_line_pointer += 6; s_data(); return; } if (strncmp(input_line_pointer, "\"data1\"", 7) == 0) { input_line_pointer += 7; s_data1(); return; } as_warn("Unknown segment type"); demand_empty_rest_of_line(); return; }