home *** CD-ROM | disk | FTP | other *** search
/ Simtel MSDOS - Coast to Coast / simteldosarchivecoasttocoast2.iso / pgmutil / val_link.zip / SUBS.H < prev    next >
Text File  |  1989-02-18  |  17KB  |  429 lines
  1. /*                                 SUBS.H                                  */
  2.  
  3. memory_descriptor_ptr
  4.       add_chunk_to_memory              (pool_descriptor_ptr pool,
  5.                                         bit_32              size);
  6. string_ptr
  7.       add_extension_to_file            (string_ptr fn,
  8.                                         string_ptr ext);
  9. void
  10.       add_files_to_list                (file_info_list    *file_list,
  11.                                         string_ptr         fn);
  12. void
  13.       align_active_segment             (void);
  14. byte_ptr
  15.       allocate_memory                  (pool_descriptor_ptr pool,
  16.                                         bit_32             size);
  17. string_ptr
  18.       allocate_string                  (pool_descriptor_ptr pool,
  19.                                         bit_16             length);
  20. string_ptr
  21.       change_extension                 (string_ptr         fn,
  22.                                         string_ptr         ext);
  23. bit_16
  24.       checksum                         (bit_16             len,
  25.                                         byte              *sym);
  26. int_16
  27.       compare_short_string             (string_ptr         left,
  28.                                         string_ptr         right);
  29. int_16
  30.       compare_string                   (string_ptr         left,
  31.                                         string_ptr         right);
  32. void
  33.       complete_a_filename_token        (void);
  34. string_ptr
  35.       concat_string                    (string_ptr         dest,
  36.                                         string_ptr         source);
  37. string_ptr
  38.       concat_char_to_string            (string_ptr         dest,
  39.                                         byte               c);
  40. string_ptr
  41.       copy_string                      (string_ptr         dest,
  42.                                         string_ptr         source);
  43. string_ptr
  44.       cut_string                       (string_ptr         dest,
  45.                                         bit_16             at,
  46.                                         bit_16             len);
  47. bit_16
  48.       continue_file_search             (void);
  49. string_ptr
  50.       default_directory                (string_ptr         drive,
  51.                                         string_ptr         directory);
  52. string_ptr
  53.       default_drive                    (void);
  54. void
  55.       DOS_error                        (char_ptr           format,
  56.                                         ...);
  57. void
  58.       DOS_int21                        (char_ptr           format,
  59.                                         ...);
  60. string_ptr
  61.       duplicate_string                 (pool_descriptor_ptr pool,
  62.                                         string_ptr          s);
  63. void
  64.       eat_white_space                  (void);
  65. string_ptr
  66.       edit_number_string               (string_ptr         s,
  67.                                         char_ptr           format,
  68.                                         ...);
  69. char_ptr
  70.       elapsed_time                     (bit_32             start,
  71.                                         bit_32             stop);
  72. void
  73.       end_linker                       (bit_16             return_code);
  74. int
  75.       far_compare                      (byte_ptr           left,
  76.                                         byte_ptr           right,
  77.                                         bit_16             len);
  78. bit_16
  79.       far_index                        (byte_ptr           dest,
  80.                                         byte               c);
  81. bit_16
  82.       far_match                        (byte_ptr           pattern,
  83.                                         byte_ptr           source,
  84.                                         bit_16             len);
  85. byte_ptr
  86.       far_move                         (byte_ptr           dest,
  87.                                         byte_ptr           source,
  88.                                         bit_16             len);
  89. byte_ptr
  90.       far_move_left                    (byte_ptr           dest,
  91.                                         byte_ptr           source,
  92.                                         bit_16             len);
  93. byte_ptr
  94.       far_set                          (byte_ptr           dest,
  95.                                         byte               source,
  96.                                         bit_16             len);
  97. byte_ptr
  98.       far_to_lower                     (byte_ptr           dest,
  99.                                         bit_16             len);
  100. void
  101.       file_close_for_read              (void);
  102. void
  103.       file_close_for_write             (void);
  104. void
  105.       file_delete                      (file_info_ptr      file_info);
  106. bit_16
  107.       file_exists                      (string_ptr         fn,
  108.                                         bit_16             attr);
  109. void
  110.       file_IO_limit                    (bit_16             limit);
  111. void
  112.       file_open_for_read               (file_info_ptr      file_info);
  113. void
  114.       file_open_for_write              (file_info_ptr      file_info);
  115. void
  116.       file_position                    (bit_32             position);
  117. void
  118.       file_read                        (byte_ptr           into,
  119.                                         bit_16             length);
  120. void
  121.       file_write                       (byte_ptr           from,
  122.                                         bit_32             length);
  123. void
  124.       fixup_FIXUPP_record              (void);
  125. void
  126.       fixup_FORREF_record              (void);
  127. void
  128.       fixup_LEDATA_record              (void);
  129. void
  130.       fixup_LIDATA_IDB                 (void);
  131. void
  132.       fixup_LIDATA_record              (void);
  133. void
  134.       fixups                           (void);
  135. bit_32
  136.       frame                            (void);
  137. DTA_ptr
  138.       get_DTA_address                  (void);
  139. void
  140.       get_filename_token               (bit_16             required,
  141.                                         file_info_list    *list);
  142. void
  143.       get_filenames_from_user          (bit_16             argc,
  144.                                         byte              *argv[]);
  145. token_stack_ptr
  146.       get_free_token_source_element    (void);
  147. void
  148.       get_order_token                  (void);
  149. bit_32
  150.       get_time                         (void);
  151. bit_16
  152.       index_string                     (string_ptr         s,
  153.                                         bit_16             from,
  154.                                         string_ptr         pattern);
  155. void
  156.       initialize_memory                (void);
  157. FILE
  158.      *input_open                       (string_ptr         fn);
  159. void
  160.       library_directory_hash           (byte_ptr           sym,
  161.                                         bit_16             len,
  162.                                         bit_16            *starting_block,
  163.                                         bit_16            *delta_block,
  164.                                         bit_16            *starting_entry,
  165.                                         bit_16            *delta_entry);
  166. void
  167.       linker_error                     (bit_16             severity,
  168.                                         char_ptr           format,
  169.                                         ...);
  170. void
  171.       linker_message                   (char_ptr           format,
  172.                                         ...);
  173. void
  174.       linker_statistics                (void);
  175. void
  176.       link_map                         (void);
  177. void
  178.       ListDelete                       (Generic_Element_ptr   elem,
  179.                                         Generic_Element_list far *lst);
  180. void
  181.       ListInsert                       (Generic_Element_ptr   elem,
  182.                                         bit_16                type_insert,
  183.                                         Generic_Element_ptr   aftr,
  184.                                         Generic_Element_list far *lst);
  185. void
  186.       ListPop                          (Generic_Element_list far *lst,
  187.                                         Generic_Element_ptr  *elem);
  188. group_entry_ptr
  189.       lookup_group                     (lname_entry_ptr    group_lname);
  190. lname_entry_ptr
  191.       lookup_lname                     (bit_16             len,
  192.                                         byte              *sym);
  193. public_entry_ptr
  194.       lookup_public                    (bit_16             len,
  195.                                         byte              *sym,
  196.                                         bit_16             module);
  197. segment_entry_ptr
  198.       lookup_segment                   (lname_entry_ptr    segment_lname,
  199.                                         lname_entry_ptr    class_lname,
  200.                                         combine_type       combine);
  201. string_ptr
  202.       lowercase_string                 (string_ptr         s);
  203. string_ptr
  204.       make_constant_string             (pool_descriptor_ptr pool,
  205.                                         byte              *s);
  206. void
  207.       make_EXE_header                  (void);
  208. void 
  209.       map_memory                       (byte_ptr           data,
  210.                                         bit_32             address,
  211.                                         bit_32             length);
  212. bit_16
  213.       match_pattern                    (string_ptr         pattern,
  214.                                         string_ptr         s);
  215. byte
  216.      *near_string                      (string_ptr         s);
  217. bit_16
  218.       obj_COMDEF                       (void);
  219. bit_16
  220.       obj_COMENT                       (void);
  221. bit_16
  222.       obj_component                    (void);
  223. bit_16
  224.       obj_content_def                  (void);
  225. bit_16
  226.       obj_data                         (void);
  227. bit_16
  228.       obj_data_record                  (void);
  229. bit_16
  230.       obj_debug_record                 (void);
  231. bit_16
  232.       obj_EXTDEF                       (void);
  233. bit_16
  234.       obj_FIXUPP                       (void);
  235. void
  236.       obj_FIXUPP_fixup                 (void);
  237. void
  238.       obj_fixup_LIDATA                 (void);
  239. void
  240.       obj_fixup_LIDATA_IDB             (void);
  241. void
  242.       obj_FIXUPP_thread                (void);
  243. bit_16
  244.       obj_FORREF                       (void);
  245. lseg_ptr 
  246.       obj_generate_segment             (lname_entry_ptr    segment_lname,
  247.                                         lname_entry_ptr    class_lname,
  248.                                         combine_type       combine,
  249.                                         bit_8              align,
  250.                                         lname_entry_ptr    tmodule,
  251.                                         file_info_ptr      file,
  252.                                         bit_32             address,
  253.                                         bit_32             length);
  254. bit_16
  255.       obj_GRPDEF                       (void);
  256. bit_16
  257.       obj_index_external               (void);
  258. bit_16
  259.       obj_index_group                  (void);
  260. bit_16
  261.       obj_index_LNAME                  (void);
  262. bit_16
  263.       obj_index_segment                (void);
  264. void
  265.       obj_iterated_data_block          (void);
  266. bit_32
  267.       obj_iterated_data_block_length   (void);
  268. bit_32
  269.       obj_leaf_descriptor              (void);
  270. bit_16
  271.       obj_LEDATA                       (void);
  272. bit_16
  273.       obj_LIDATA                       (void);
  274. bit_32
  275.       obj_LIDATA_length                (void);
  276. bit_16
  277.       obj_LINNUM                       (void);
  278. bit_16
  279.       obj_LNAMES                       (void);
  280. bit_16
  281.       obj_MODEND                       (void);
  282. bit_16
  283.       obj_MODEXT                       (void);
  284. bit_16
  285.       obj_MODPUB                       (void);
  286. bit_16
  287.       obj_modtail                      (void);
  288. lname_entry_ptr
  289.       obj_name                         (void);
  290. bit_16
  291.       obj_name_length                  (void);
  292. void
  293.       obj_next_record                  (void);
  294. bit_16
  295.       obj_PUBDEF                       (void);
  296. bit_16
  297.       obj_SEGDEF                       (void);
  298. bit_16
  299.       obj_seg_grp                      (void);
  300. bit_16
  301.       obj_thread_def                   (void);
  302. bit_16
  303.       obj_tmodule                      (void);
  304. bit_16
  305.       obj_THEADR                       (void);
  306. bit_16
  307.       obj_TYPDEF                       (void);
  308. void
  309.       order_and_align_segments         (void);
  310. bit_16
  311.       order_expression                 (void);
  312. bit_16
  313.       order_factor                     (void);
  314. void
  315.       order_prologue                   (void);
  316. bit_16
  317.       order_primary                    (void);
  318. bit_16
  319.       order_term                       (void);
  320. void
  321.       order_token_get_char             (void);
  322. void
  323.       parse_object_module              (void);
  324. void
  325.       pass_two                         (void);    
  326. string_ptr
  327.       paste_string                     (string_ptr         dest,
  328.                                         bit_16             at,
  329.                                         string_ptr         s);
  330. void
  331.       primary_linker_initialization    (byte              *program_directory);
  332. void
  333.       print                            (char_ptr           format,
  334.                                         ...);
  335. string_ptr
  336.       process_filename                 (string_ptr         fn);
  337. void
  338.       process_libraries                (void);
  339. void
  340.       process_library                  (file_info_ptr      lib_file);
  341. void
  342.       process_library_directories      (void);
  343. void
  344.       process_library_directory        (file_info_ptr      lib_file);
  345. void
  346.       process_object_modules           (void);
  347. void
  348.       process_switch                   (void);
  349. void
  350.       process_user_input_files         (file_info_list    *list,
  351.                                         bit_16             required);
  352. void
  353.       process_user_output_file         (file_info_list    *list,
  354.                                         bit_16             required);
  355. bit_32
  356.       public_frame_address             (public_entry_ptr   pub);
  357. bit_32
  358.       public_target_address            (public_entry_ptr   pub);
  359. void
  360.       release_pool                     (pool_descriptor_ptr pool);
  361. bit_16
  362.       reverse_index_string             (string_ptr         s,
  363.                                         bit_16             from,
  364.                                         string_ptr         pattern);
  365. void
  366.       scan_bit_16_switch               (switch_table_ptr   current_switch);
  367. void
  368.       scan_help_switch                 (switch_table_ptr   current_switch);
  369. void
  370.       scan_opt_bit_16                  (switch_table_ptr   current_switch);
  371. void
  372.       scan_out_token                   (void);
  373. void
  374.       scan_reset_bit_16                (switch_table_ptr   current_switch);
  375. void
  376.       scan_reset_switch                (switch_table_ptr   current_switch);
  377. void
  378.       scan_set_switch                  (switch_table_ptr   current_switch);
  379. void
  380.       scan_text_switch                 (switch_table_ptr   current_switch);
  381. void
  382.       secondary_linker_initialization  (void);
  383. bit_32
  384.       segment_offset                   (lseg_ptr           lseg,
  385.                                         bit_16             offset);
  386. void
  387.       set_DTA_address                  (DTA_ptr            DTA_address);
  388. void
  389.       sort_directory                   (bit_16             left,
  390.                                         bit_16             right);
  391. void
  392.       sort_publics_by_name             (bit_16             left,
  393.                                         bit_16             right);
  394. void
  395.       sort_publics_by_value            (bit_16             left,
  396.                                         bit_16             right);
  397. bit_16
  398.       start_file_search                (string_ptr         fn,
  399.                                         bit_16             attr);
  400. string_ptr
  401.       string                           (byte_ptr           s);
  402. string_ptr
  403.       substr                           (string_ptr         s,
  404.                                         bit_16             at,
  405.                                         bit_16             len);
  406. bit_32
  407.       target                           (void);
  408. void
  409.       token_get_char                   (void);
  410. string_ptr
  411.       trunc_string                     (string_ptr         s,
  412.                                         bit_16             at);
  413. bit_16
  414.       word_checksum                    (bit_16             len,
  415.                                         bit_16             address,
  416.                                         byte_ptr           data);
  417. void
  418.       write_executable_image           (void);
  419. void 
  420.       write_gap                        (bit_32             length);
  421. void
  422.       write_temp_file                  (bit_8              rec_typ,
  423.                                         lseg_ptr           lseg,
  424.                                         bit_16             offset,
  425.                                         byte_ptr           data,
  426.                                         bit_16             len);
  427.  
  428.  
  429.