order.c

CC386 is a general-purpose 32-bit C compiler. It is not an optimizing compiler but given that the co

  EndIf;
 return;
EndCode

/*+-------------------------------------------------------------------------+
  |                                                                         |
  |                         order_and_align_segments                        |
  |                                                                         |
  +-------------------------------------------------------------------------+*/
void order_and_align_segments()
BeginDeclarations
byte_ptr                               start_of_expression;
public_entry_ptr                       pub ;
group_entry_ptr												 group ;
#define Group                          (*group)
public_entry_ptr                       next_virtual ;
lseg_ptr															 lseg ;
#define Pub                            (*pub)
EndDeclarations
BeginCode
 order_start_time = Now;
/*+-------------------------------------------------------------------------+
  |                                                                         |
  | Before we can start ordering segments, we have to get some housekeeping |
  | done first.                                                             |
  |                                                                         |
  +-------------------------------------------------------------------------+*/

 order_prologue();

/*+-------------------------------------------------------------------------+
  |                                                                         |
  |              OK, lets get to ordering and aligning segments.            |
  |                                                                         |
  +-------------------------------------------------------------------------+*/
 First(segments_ordered_list) =
 Last(segments_ordered_list)  = Null;
 highest_uninitialized_byte = 0L;
 start_of_expression = String(ordering.val);
 start_of_expression++;
 While *start_of_expression IsNot '\000'
  BeginWhile
   ExitIf(segment_list.first IsNull);
   First(segments_unordered_list) =
   Last(segments_unordered_list)  = Null;
   While segment_list.first IsNotNull
    BeginWhile
     Pop segment_list InTo active_segment EndPop;
     order_expression_char_ptr = start_of_expression;
     token_break_char = ' ';
     If (Active_segment.segment_name Is codeview_segment_BROWSE) AndIf
          (Active_segment.class_name Is codeview_class_DEBBROWSE)
       Then /* always eat browse segments */
            order_expression() ;
       Else
         If codeview_information_present AndIf
            (((Active_segment.segment_name Is codeview_segment_TYPES) AndIf
              (Active_segment.class_name Is codeview_class_DEBTYP)) OrIf
             ((Active_segment.segment_name Is codeview_segment_SYMBOLS) AndIf
              (Active_segment.class_name Is codeview_class_DEBSYM)))
          Then /* Eat the codeview segment */
            order_expression() ;
          Else /* Process all non-codeview segments */
           If order_expression()
            Then
             Insert active_segment AtEnd InList segments_ordered_list EndInsert;
             align_active_segment();
            Else
             Insert active_segment AtEnd InList segments_unordered_list EndInsert;
            EndIf;
          EndIf;
       EndIf;
    EndWhile;
   If (lxfile.val IsTrue OrIf lefile.val IsTrue) AndIf TokenIsNot(semicolon_string)
      Then
         lx_align_object() ;
      EndIf ;
   If pefile.val IsTrue AndIf TokenIsNot(semicolon_string)
		Then
			pe_align_object();
		EndIf ;
   start_of_expression = order_expression_char_ptr;
   start_of_expression--;
   segment_list = segments_unordered_list;
  EndWhile;

/*+-------------------------------------------------------------------------+
  |                                                                         |
  |          Make one final pass accepting all remaining segments.          |
  |                                                                         |
  +-------------------------------------------------------------------------+*/

 While segment_list.first IsNotNull
  BeginWhile
   Pop segment_list InTo active_segment EndPop;
   Insert active_segment AtEnd InList segments_ordered_list EndInsert;
   align_active_segment();
   If lxfile.val IsTrue OrIf lefile.val IsTrue
      Then
         lx_align_object() ;
      EndIf ;
   If pefile.val IsTrue
    Then
     pe_align_object() ;
    EndIf ;
  EndWhile;
 segment_list = segments_ordered_list;
/*+-------------------------------------------------------------------------+
  |                                                                         |
  |          Calculate the offset of virtual segments                       |
  |                                                                         |
  +-------------------------------------------------------------------------+*/
   For pub= virtual_segs; pub IsNotNull; pub=next_virtual
    BeginFor
     next_virtual         = Pub.Virtual.next_virtual;
     LoopIf(Pub.type_entry IsNot virtual_segment);
		 group = (*(*Pub.Virtual.enclosing_segment).segment).owning_group ;
     lseg    = Pub.Virtual.lseg;
		 memset(&Pub.Internal,0,sizeof(Pub.Internal)) ;
     Pub.type_entry       = internal;
     Pub.Internal.lseg    = lseg;
     Pub.Internal.group   = group;
     Pub.Internal.frame   = 0;
    EndFor;

   If lxfile.val IsFalse AndIf lefile.val IsFalse AndIf pefile.val IsFalse AndIf comfile.val IsFalse
    Then
     group                        = lookup_group(DGROUP_lname);
     If group AndIf Group.first_segment IsNotNull
      Then
       FLAT_address = (*Group.first_segment).address ;
      Else
       linker_error(4, "Dos 32-bit module error: DGROUP not present\n") ;
      EndIf
    EndIf ;

 return;
EndCode
#undef Group
#undef Pub

/*+-------------------------------------------------------------------------+
  |                                                                         |
  |                            order_expression                             |
  |                                                                         |
  +-------------------------------------------------------------------------+*/
bit_16 order_expression()
BeginDeclarations
bit_16                                 left_operand;
EndDeclarations
BeginCode
 get_order_token();
 left_operand = order_term();
 While TokenIs(or_string)   OrIf
       TokenIs(plus_string) OrIf
       TokenIs(bar_string)
  BeginWhile
   get_order_token();
   left_operand |= order_term();
  EndWhile;
 return(left_operand);
EndCode

/*+-------------------------------------------------------------------------+
  |                                                                         |
  |                               order_term                                |
  |                                                                         |
  +-------------------------------------------------------------------------+*/
bit_16 order_term()
BeginDeclarations
bit_16                                 left_operand;
EndDeclarations
BeginCode
 left_operand = order_factor();
 While TokenIs(and_string)       OrIf
       TokenIs(star_string)      OrIf
       TokenIs(ampersand_string)
  BeginWhile
   get_order_token();
   left_operand &= order_factor();
  EndWhile;
 return(left_operand);
EndCode

/*+-------------------------------------------------------------------------+
  |                                                                         |
  |                             order_factor                                |
  |                                                                         |
  +-------------------------------------------------------------------------+*/
bit_16 order_factor()
BeginDeclarations
bit_16                                 unary_not;
EndDeclarations
BeginCode
 unary_not = False;
 While TokenIs(exclamation_string) OrIf
       TokenIs(tilde_string)       OrIf
       TokenIs(minus_string)       OrIf
       TokenIs(not_string)
  BeginWhile
   get_order_token();
   unary_not ^= True;
  EndWhile;
 return(unary_not ^ order_primary());
EndCode

/*+-------------------------------------------------------------------------+
  |                                                                         |
  |                             order_primary                               |
  |                                                                         |
  +-------------------------------------------------------------------------+*/
bit_16 order_primary()
BeginDeclarations
group_entry_ptr                        group;
#define Group                          (*group)
bit_16                                 operand;
EndDeclarations
BeginCode
 If TokenIs(true_string)
  Then
   get_order_token();
   return(True);
  EndIf;
 If TokenIs(false_string)
  Then
   get_order_token();
   return(False);
  EndIf;
 If TokenIs(open_paren_string)
  Then
   operand = order_expression();
   If TokenIs(close_paren_string)
    Then
     get_order_token();
     return(operand);
    Else
     linker_error(8, "Expression syntax error:\n"
                     "\t\"%s\"\n",
                     String(ordering.val));
    EndIf;
  EndIf;
 If TokenStartsWith(segment_string)
  Then
   get_order_token();
   If *String(token) IsNot '['
    Then
     linker_error(8, "Expression syntax error:\n"
                     "\t\"%s\"\n",
                     String(ordering.val));
    EndIf;
   cut_string(token, 0, 1);
   operand = match_pattern(token,
                           string((*Active_segment.segment_name).symbol));
   get_order_token();
   return(operand);
  EndIf;
 If TokenStartsWith(group_string)
  Then
   get_order_token();
   If *String(token) IsNot '['
    Then
     linker_error(8, "Expression syntax error:\n"
                     "\t\"%s\"\n",
                     String(ordering.val));
    EndIf;
   cut_string(token, 0, 1);
   group = Active_segment.owning_group;
   If group IsNull
    Then
     operand = False;
    Else
     operand =
      match_pattern(token, string((*Group.group_name).symbol));
    EndIf;
   get_order_token();
   return(operand);
  EndIf;
 If TokenStartsWith(class_string)
  Then
   get_order_token();
   If *String(token) IsNot '['
    Then
     linker_error(8, "Expression syntax error:\n"
                     "\t\"%s\"\n",
                     String(ordering.val));
    EndIf;
   cut_string(token, 0, 1);
   operand = match_pattern(token,
                           string((*Active_segment.class_name).symbol));
   get_order_token();
   return(operand);
  EndIf;
 linker_error(8, "Expression syntax error:\n"
                 "\t\"%s\"\n",
                 String(ordering.val));
 return(False);
EndCode
#undef Group

/*+-------------------------------------------------------------------------+
  |                                                                         |
  |                              order_prologue                             |
  |                                                                         |
  +-------------------------------------------------------------------------+*/
void order_prologue()
BeginDeclarations
group_entry_ptr                        group;
#define Group                          (*group)
bit_32                                 length;
lseg_ptr                               lseg;
#define Lseg                           (*lseg)
public_entry_ptr                       next_communal;
bit_16                                 offset;
public_entry_ptr                       pub;
#define Pub                            (*pub)