Patch title: Release 85 bulk changes
Abstract:
File: /pliant/language/declare/proto.c
Key:
    Removed line
    Added line
// Copyright  Hubert Tonneau  hubert.tonneau@pliant.cx
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License version 2
// as published by the Free Software Foundation.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

/*
abstract
  text "This program declares the prototypes of most of the C functions defined in the C part of the Pliant compiler kernel."
doc
  text "Does not worth reading."
*/


/* address.c */

PROTOTYPE uInt integer_from_address(Address a);
PROTOTYPE Address address_from_integer(uInt i);
PROTOTYPE Address address_translate(Address a,Int offset);


/* bit.c */

PROTOTYPE Int bit_size(Int nb);
PROTOTYPE Void bit_set(Address adr,Int index);
PROTOTYPE Void bit_clear(Address adr,Int index);
PROTOTYPE Bool bit_test(Address adr,Int index);


/* int.c */

#ifdef _64BITS_
  #define int_min 0x8000000000000001
  #define int_max 0x7FFFFFFFFFFFFFFF
  #define int_bad 0x8000000000000000
#else
  #define int_min 0x80000001
  #define int_max 0x7FFFFFFF
  #define int_bad 0x80000000
#endif

PROTOTYPE Int minimum(Int a,Int b);
PROTOTYPE Int maximum(Int a,Int b);
#ifndef _LINUX_API_
  #include <stdlib.h>
  #define abs myabs
#endif
PROTOTYPE Int abs(Int i);
PROTOTYPE Int Int_str2(Int i,Int base,Char *buf);

PROTOTYPE uInt round_down(uInt i,uInt modulus);
PROTOTYPE uInt round_up(uInt i,uInt modulus);


/* random.c */

PROTOTYPE uInt32 random32();


/* memory.c */

PROTOTYPE Address memory_page_reserve(Address wished_address,Int size);
PROTOTYPE Void memory_page_commit(Address address,Int size);
PROTOTYPE Void memory_page_decommit(Address address,Int size);
PROTOTYPE Void memory_page_release(Address address,Int size);

PROTOTYPE Void memory_clear(Address address,Int size);
PROTOTYPE Void memory_copy(Address src,Address dest,Int size);
PROTOTYPE Void memory_move(Address src,Address dest,Int size);
PROTOTYPE Int memory_compare(Address area1,Int size1,Address area2,Int size2);
PROTOTYPE Bool memory_different(Address area1,Int size1,Address area2,Int size2);
PROTOTYPE Address memory_search(Address address,Int size,Address pattern_address,Int pattern_size);


/* atomic.c */

PROTOTYPE Void atomic_increment(volatile Int *variable);
PROTOTYPE Bool atomic_decrement_and_test_zero(volatile Int *variable);
PROTOTYPE Void atomic_add(volatile Int *variable,Int value);


/* process.c */

PROTOTYPE Void process_get_parameters(Char **line,Int *len);
PROTOTYPE Void process_exit(Int retcode);

/* error.c */

#ifdef _CHECK_
  PROTOTYPE Void check_assertion(Bool cond,Char *expression,Char *filename,Int linenum);
  #define check(cond) check_assertion(cond,#cond,__FILE__,__LINE__)
#else
  #define check(cond)
#endif

PROTOTYPE Void error_notify_fatal(Int id,struct Str *message);
PROTOTYPE Void error_notify_fatalz(Int id,Char *message);
PROTOTYPE Void ErrorRecord_build(struct ErrorRecord *e);
PROTOTYPE Void ErrorRecord_destroy(struct ErrorRecord *e);
PROTOTYPE Void error_push_record(struct ErrorRecord *e,Int filter);
PROTOTYPE Void error_pull_record(struct ErrorRecord *e);
PROTOTYPE struct ErrorRecord *error_top_record();
PROTOTYPE Void error_notify(Int id,Arrow context,struct Str *message);
PROTOTYPE Void error_renotify(Int id,Arrow context,struct Str *message);
PROTOTYPE Void error_notifyn(Int id,...);
PROTOTYPE Bool error_notified();
PROTOTYPE Void error_report();
PROTOTYPE Int error_allocate_id(struct Str *clear_text_message);
PROTOTYPE Void ActionRecord_build(struct ActionRecord *ca);
PROTOTYPE Void ActionRecord_destroy(struct ActionRecord *ca);
PROTOTYPE Void action_push_record(struct ActionRecord *ca,struct Str *action);
PROTOTYPE Void action_pull_record(struct ActionRecord *ca);
PROTOTYPE struct ActionRecord *action_top_record();
PROTOTYPE Void error_propagate(struct ErrorRecord *src,struct ErrorRecord *dest);


/* alloc.c */

PROTOTYPE Address memory_allocate(Int size,Address with);
PROTOTYPE Address memory_resize(Address address,Int newsize,Address with);
PROTOTYPE Address memory_zallocate(Int size,Address with);
PROTOTYPE Address memory_zresize(Address address,Int newsize,Address with);
PROTOTYPE Void memory_free(Address address);
PROTOTYPE Int memory_size(Address address);
PROTOTYPE Void memory_checkup();
PROTOTYPE Void memory_shrink(Bool clearalso);

PROTOTYPE Address MemoryPool_allocate(struct MemoryPool *pool,Int size,Address with);
PROTOTYPE Address MemoryPool_resize_pool(struct MemoryPool *pool,Address address,Int newsize,Address with);
PROTOTYPE Address MemoryPool_zallocate_pool(struct MemoryPool *pool,Int size,Address with);
PROTOTYPE Address MemoryPool_zresize(struct MemoryPool *pool,Address address,Int newsize,Address with);
PROTOTYPE Void MemoryPool_free(struct MemoryPool *pool,Address address);
PROTOTYPE Void MemoryPool_checkup(struct MemoryPool *pool);
PROTOTYPE Void MemoryPool_shrink(struct MemoryPool *pool,Bool clearalso);


/* entry.c */

PROTOTYPE Arrow entry_new(struct Type *type);
PROTOTYPE Void entry_lock(Arrow object);
PROTOTYPE Void entry_unlock(Arrow object);
PROTOTYPE Void entry_lockz(Arrow object);
PROTOTYPE Void entry_unlockz(Arrow object);
PROTOTYPE Void entry_root(Arrow object);
#ifdef _CHECK_
  PROTOTYPE Void entry_check(Arrow object,Char *operation);
#endif

PROTOTYPE struct EntryHeader *entry_header(Arrow object);
PROTOTYPE struct Type *entry_type(Arrow object);

PROTOTYPE Arrow entry(struct Type *type, ...);
PROTOTYPE Address C_map(Char *name,struct Module *module,Arrow object,Int access);
PROTOTYPE Address C_constant(Char *name,struct Module *module,Arrow object);

PROTOTYPE Void Arrow_build(Arrow *ref);
PROTOTYPE Void Arrow_destroy(Arrow *ref);
PROTOTYPE Void Arrow_copy(Arrow *src,Arrow *dest);

PROTOTYPE Void Arrow_set(Arrow *ref,Arrow object);


/* str.c */

PROTOTYPE uInt string_len(const Char *string);
PROTOTYPE Void string_Str(Char *src,struct Str *dest);

PROTOTYPE Void Str_build(struct Str *str);
PROTOTYPE Void Str_destroy(struct Str *str);
PROTOTYPE Void Str_copy(struct Str *src,struct Str *dest);

INLINE Int Str_len(struct Str *s);
PROTOTYPE Void Str_set(struct Str *dest,Char *chars,Int len,Bool allocated);
PROTOTYPE Void Str_resize(struct Str *dest,Int len);

PROTOTYPE Int compare_str(struct Str *s1,struct Str *s2);
PROTOTYPE Int Str_search(struct Str *string,struct Str *pattern,Int ifnotfound);
PROTOTYPE Void Str_add(struct Str *src,struct Str *dest);
PROTOTYPE Void Str_addz(Char *src,struct Str *dest);
PROTOTYPE Void Str_concat(struct Str *dest, ...);
PROTOTYPE Char *Str_string(struct Str *str);

PROTOTYPE struct Str *Str_map_string(struct Str *str,Char *string);
PROTOTYPE struct Str *Str_map_area(struct Str *str,Char *chars,Int len);


/* list.c */

PROTOTYPE Void List_build(struct List *list);
PROTOTYPE Void List_destroy(struct List *list);
PROTOTYPE Void List_copy(struct List *src,struct List *dest);

PROTOTYPE Arrow *List_first(struct List *list);
PROTOTYPE Arrow *List_last(struct List *list);
PROTOTYPE Arrow *List_next(Arrow *current);
PROTOTYPE Arrow *List_previous(Arrow *current);

PROTOTYPE Arrow *List_append(struct List *list,Arrow object);
PROTOTYPE Arrow *List_insert_before(struct List *list,Arrow *before,Arrow object);
PROTOTYPE Arrow *List_insert_after(struct List *list,Arrow *after,Arrow object);
PROTOTYPE Arrow *List_remove(struct List *list,Arrow *current);


/* array.c */

PROTOTYPE Void Array_build(struct Array *array);
PROTOTYPE Void Array_destroy(struct Array *array);
PROTOTYPE Void Array_copy(struct Array *src,struct Array *dest);

PROTOTYPE Void Array_resize(struct Array *array,Int nb);
PROTOTYPE Void Array_extend(struct Array *array,Int nb);

PROTOTYPE Arrow Array_get_index(struct Array *array,Int index);
PROTOTYPE Void Array_set_index(struct Array *array,Int index,Arrow object);


/* dict.c */

PROTOTYPE uInt compute_key(Address address,Int size);

PROTOTYPE Void Dictionary_build(struct Dictionary *dict);
PROTOTYPE Void Dictionary_destroy(struct Dictionary *dict);

INLINE Int Dictionary_count(struct Dictionary *dict);
PROTOTYPE Void Dictionary_insert(struct Dictionary *dict,struct Str *label,Bool ahead,Arrow object);
PROTOTYPE Void Dictionary_insert2(struct Dictionary *dict,struct Str *label,Bool ahead,Arrow object,struct Module *module);
PROTOTYPE Void Dictionary_remove(struct Dictionary *dict,struct Str *label,Arrow object);

PROTOTYPE Arrow *Dictionary_first(struct Dictionary *dict,struct Str *label);
PROTOTYPE Arrow *Dictionary_next(struct Dictionary *dict,struct Str *label,Arrow *reference);

PROTOTYPE Void Dictionary_resize(struct Dictionary *dict,Int size);
PROTOTYPE Void Dictionary_freeze(struct Dictionary *dict);


/* relation.c */

PROTOTYPE uInt compute_key2(Address address1,Address address2);

PROTOTYPE Void Relation_build(struct Relation *relation);
PROTOTYPE Void Relation_destroy(struct Relation *relation);

PROTOTYPE Address Relation_define(struct Relation *relation,Address address1,Address address2,Arrow object);
PROTOTYPE Address Relation_query(struct Relation *relation,Address address1,Address address2);
PROTOTYPE Void Relation_resize(struct Relation *relation,Int size);


/* module.c */

PROTOTYPE Void Module_build(struct Module *module);
PROTOTYPE Void Module_destroy(struct Module *module);

PROTOTYPE Void Module_add_scope(struct Module *m,struct Str *scope);
PROTOTYPE Void Module_define(struct Module *module,struct Str *name,Arrow object);
PROTOTYPE Address Module_mark(struct Module *module);
PROTOTYPE Void Module_rewind(struct Module *module,Address mark);
PROTOTYPE struct Module *Module_actual(struct Module *module);

PROTOTYPE Void Module_include(struct Module *module,struct Module *submodule,Int flags);
PROTOTYPE Bool Module_is_included(struct Module *module,struct Module *submodule);

PROTOTYPE struct Module *load_module(struct Str *filename,struct Module *include,Int flag,struct Module *parent);


/* file.c */

FUNCTION Any file_open(struct Str *name,Int mode);
FUNCTION Int file_read(Any handle,Address buffer,Int size);
FUNCTION Int file_write(Any handle,Address buffer,Int size);
FUNCTION Err file_close(Any handle);


#define file_in          0x01
#define file_out         0x02
#define file_in_out      0x03


/* console.c */

PROTOTYPE Void console(struct Str *message);
PROTOTYPE Void consolen(Int kind, ...);
#define S 1
#define Z 2
#define EOL 3
#define EOS 4


/* argument.c */

PROTOTYPE Void Argument_build(struct Argument *arg);
PROTOTYPE Void Argument_destroy(struct Argument *arg);

PROTOTYPE Void Argument_locate(struct Argument *arg,struct Type *type,Int where);
PROTOTYPE Bool Argument_is_shared(struct Argument *arg1,struct Argument *arg2);

PROTOTYPE struct Argument *argument(struct Type *type,Int where, ...);


/* instruction.c */

PROTOTYPE Void Instruction_build(struct Instruction *instr);
PROTOTYPE Void Instruction_destroy(struct Instruction *instr);

PROTOTYPE Void Instruction_set_function(struct Instruction *instr,struct Function *fun);
PROTOTYPE Void Instruction_set_argument(struct Instruction *instr,Int index,struct Argument *arg);
PROTOTYPE Void Instruction_set_jump(struct Instruction *instr,struct Instruction *jump);

PROTOTYPE Void Instruction_link(struct Instruction *instr,struct Instruction *master);
PROTOTYPE Void Instruction_generate_assembly(struct Instruction *instr,struct GeneratorContext *gc);
PROTOTYPE Void Instruction_generate_binary(struct Instruction *instr,struct Function *function);

PROTOTYPE struct Instruction *instruction(struct Function *fun, ...);


/* executable.c */

PROTOTYPE Void GeneratorContext_build(struct GeneratorContext *gc);
PROTOTYPE Void GeneratorContext_destroy(struct GeneratorContext *gc);

PROTOTYPE Void GeneratorContext_setup(struct GeneratorContext *gc,struct Expression *expr,struct Function *function);
PROTOTYPE struct Instruction *GeneratorContext_insert_at_section_top(struct GeneratorContext *gc,Int section,struct Instruction *instr);
PROTOTYPE struct Instruction *GeneratorContext_insert_at_section_bottom(struct GeneratorContext *gc,Int section,struct Instruction *instr);
PROTOTYPE struct Instruction *GeneratorContext_insert_before_instruction(struct GeneratorContext *gc,struct Instruction *insertbefore,struct Instruction *instr);
PROTOTYPE struct Instruction *GeneratorContext_insert_after_instruction(struct GeneratorContext *gc,struct Instruction *insertafter,struct Instruction *instr);
PROTOTYPE struct Instruction *GeneratorContext_remove(struct GeneratorContext *gc,struct Instruction *instr);
PROTOTYPE Void GeneratorContext_suckup(struct GeneratorContext *gc,struct Argument *suckedup,struct Argument *master);

PROTOTYPE Void GeneratorContext_optimize(struct GeneratorContext *gc);


/* function.c */

PROTOTYPE Void Function_build(struct Function *f);
PROTOTYPE Void Function_destroy(struct Function *f);

PROTOTYPE Void Function_define_arguments_prototypes(struct Function *f,Int nb_arg,Int nb_res);
PROTOTYPE Void Function_define_argument_prototype(struct Function *f,struct Type *type,Int access,struct Str *name,Address default_value);
PROTOTYPE Void Function_terminate_arguments_prototypes(struct Function *f,Int extra_flags);
PROTOTYPE struct Function *Function_watch_generic(struct Function *f);
PROTOTYPE Void Function_set_generate_assembly1(struct Function *f,FunctionAssemblyPrototype ga);
PROTOTYPE Void Function_set_generate_binary1(struct Function *f,FunctionBinaryPrototype gb);

PROTOTYPE Void Function_record_external(struct Function *fun,Arrow ref,Bool record_offset);
PROTOTYPE Void Function_code_immediat(struct Function *fun,Int value,Int size);
PROTOTYPE Void Function_code_jump_instruction(struct Function *fun,struct Instruction *instruction);
PROTOTYPE Void Function_code_jump_function(struct Function *fun,struct Function *function);
PROTOTYPE Void Function_terminate_code(struct Function *fun);

PROTOTYPE struct Function *C_function2(Char *name,Address cfun);
#define C_function0(cfun) C_function2(#cfun,cfun)
PROTOTYPE struct Function *C_function(Char *name,struct Module *module,Address cfun,Int flags, ...);
PROTOTYPE struct Function *C_meta(Char *name,struct Module *module,FunctionMacroPrototype cfun,Int flags);


/* generic.c */

PROTOTYPE Void generic_set_nb_methods_indices(Int nb);
PROTOTYPE Int generic_allocate_method(struct Type *type);
PROTOTYPE Void Type_set_generic_method(struct Type *type,Int method_handle,struct Function *function);
PROTOTYPE struct Function *Type_get_generic_method(struct Type *type,Int method_handle);
PROTOTYPE Address Type_get_generic_method_executable(struct Type *type,Int method_handle);


/* type.c */

PROTOTYPE Void Type_build(struct Type *type);
PROTOTYPE Void Type_destroy(struct Type *type);
#ifdef _CHECK_
  INLINE Err Type_is_corrupted(struct Type *type);
#endif

PROTOTYPE Void Type_define_field(struct Type *type,struct Type *ftype,struct Str *fname,Address initial_value);
PROTOTYPE Void Type_terminate_fields(struct Type *type);
PROTOTYPE Void Type_may_be(struct Type *generic_type,struct Type *type);
PROTOTYPE Void Type_recurse_may_be(struct Type *type);

PROTOTYPE Void Type_build_instance(struct Type *type,Address instance);
PROTOTYPE Void Type_destroy_instance(struct Type *type,Address instance);
PROTOTYPE Void Type_copy_instance(struct Type *type,Address src,Address dest);

PROTOTYPE struct Type *C_type0(Char *name,struct Module *module,Int size,Int flags,Address build,Address destroy,Address copy);
PROTOTYPE struct Type *C_type(Char *name,struct Module *module,Int size, ...);
PROTOTYPE struct Function *C_field(struct Type *type,Char *fieldname,struct Module *module,struct Type *fieldtype,Int fieldoffset,Int access);


/* expr.c */

PROTOTYPE Void Expression_build(struct Expression *e);
PROTOTYPE Void Expression_destroy(struct Expression *e);
PROTOTYPE Void Expression_copy(struct Expression *src,struct Expression *dest);

PROTOTYPE Void Expression_add(struct Expression *e,struct Instruction *instruction);
PROTOTYPE Void Expression_set_result(struct Expression *e,struct Argument *a,Int access);
PROTOTYPE Void Expression_set_constant_result(struct Expression *e,Arrow value);
PROTOTYPE Void Expression_set_void_result(struct Expression *e);

PROTOTYPE Void Expr_suckup(struct Expression *e,struct Expression *sub);

PROTOTYPE Void Expression_precompile_rewrite(struct Expression *e);
PROTOTYPE Void Expression_postcompile_rewrite(struct Expression *e);
PROTOTYPE Void Expression_failedtocompile_rewrite(struct Expression *e);
PROTOTYPE Bool Expression_is_compiled(struct Expression *e);
PROTOTYPE Void _EXTERNAL_ Expression_compile(struct Expression *e);
PROTOTYPE Void Expression_compile_step2(struct Expression *e);
PROTOTYPE Void Expression_compile_step3(struct Expression *e);
PROTOTYPE Void Expression_compile_step4(struct Expression *e,Arrow object,Int access);
PROTOTYPE Void Expression_uncompile(struct Expression *e);
PROTOTYPE Bool Expression_cast(struct Expression *e,struct Type *wished_type);
PROTOTYPE Void Expression_uncast(struct Expression *e);
PROTOTYPE Void _EXTERNAL_ Expression_execute(struct Expression *e);
PROTOTYPE Address _EXTERNAL_ Expression_evaluate(struct Expression *e);
PROTOTYPE Address Expression_pure_ident(struct Expression *e);
PROTOTYPE Address Expression_constant(struct Expression *e,struct Type *wished_type);

/* active.c */

FUNCTION Void call_active(Arrow object, Int access, struct Expression *e);

/* compile.c */

#define compile_error Module_set_error
#define compile_error2 Module_set_error2
#define compile_errorz Module_set_errorz
#define compile_error_position Module_set_error_position

PROTOTYPE Void active_type_Argument(Arrow object,Int access,struct Expression *e);


/* parser.c */

PROTOTYPE Bool isidentdigit(Char c);

PROTOTYPE struct Expression *ParserContext_add_token(struct ParserContext *context,Address value);
PROTOTYPE struct Expression *ParserContext_add_ident(struct ParserContext *context,struct Str *ident);
PROTOTYPE Void ParserContext_open_sublevel(struct ParserContext *context,struct Str *closeop);
PROTOTYPE Void ParserContext_close_sublevel(struct ParserContext *context,struct Str *closeop);
PROTOTYPE Void ParserContext_add_pending(struct ParserContext *context,Int y,Int x,struct Function *function,Address parameter);
PROTOTYPE Void ParserContext_forward(struct ParserContext *context,Int nb_chars);

PROTOTYPE Void fold_arguments(struct Array *arguments,Int center,Int nb_before,Address before_value,Int nb_after,Address after_value);

PROTOTYPE Void compile_text(struct List *text,struct Module *module);


/* i386.c */

PROTOTYPE Void generate_i386_call(struct Instruction *instr,struct Function *fun);
PROTOTYPE Void generate_i386_call_generic(struct Instruction *instr,struct Function *fun);


/* pointer.c */

PROTOTYPE struct Type *pointerto(struct Type *type);
PROTOTYPE struct Type *linkto(struct Type *type);
PROTOTYPE struct Type *unpointerto(struct Type *type);
PROTOTYPE Bool type_is_pointer(struct Type *type);
PROTOTYPE Bool type_is_link(struct Type *type);


/* extend.c */

PROTOTYPE struct Function *current_function();
PROTOTYPE Void restore_externals();