/* Version 1.1 23-1-1996 */ #include "compiledefines.h" #define D 0 #define class class_is_keyword #define new new_is_keyword #define STRUCT(struct_name,type_name) \ typedef struct struct_name type_name##S; \ typedef struct struct_name *type_name; \ typedef struct struct_name *type_name##P; \ struct struct_name typedef unsigned long BITVECT; typedef enum { NoAttr, DeferAttr, CopyAttr } GraphAttributeKind; typedef enum { NotUsed, UniquelyUsed, SelectivelyUsed, MultiplyUsed, ObservinglyUsed } OccurrenceKind; typedef enum { TupleState, ArrayState, RecordState, SimpleState } StateType; /* the order of the StateKinds is used by IsLazyState and ExpectsResultNode */ typedef enum { OnB, LazyRedirection, StrictRedirection, /* strict states, no result node */ StrictOnA, /* strict state, result node */ OnA, SemiStrict, Parallel, Undefined, UnderEval /* lazy states, result node */ } StateKind; typedef enum { UnknownObj, #if ABSTRACT_OBJECT AbstractObj, #endif IntObj, BoolObj, CharObj, RealObj, FileObj, StringObj, TupleObj, ListObj, RecordObj, ArrayObj, StrictArrayObj, UnboxedArrayObj, WorldObj, ProcIdObj, RedIdObj #ifdef CLEAN2 ,DynamicObj #endif , NrOfObjects } ObjectKind; #if ABSTRACT_OBJECT # define BASIC_ELEMS_STRING "uuibcrfsaaaaaaippa" /* index by ObjectKind */ #else # define BASIC_ELEMS_STRING "uibcrfsaaaaaaippa" /* index by ObjectKind */ #endif typedef enum { int_type, bool_type, char_type, real_type, file_type, string_type,world_type, procid_type, redid_type, Nr_Of_Basic_Types, int_denot, bool_denot, char_denot, real_denot, Nr_Of_Basic_Denots, string_denot, fun_type, array_type, strict_array_type, unboxed_array_type, list_type, tuple_type, empty_type, #ifdef CLEAN2 dynamic_type, #endif Nr_Of_Predef_Types, tuple_symb, cons_symb, nil_symb, apply_symb, if_symb, fail_symb, all_symb, select_symb, Nr_Of_Predef_FunsOrConses, definition, newsymbol, instance_symb, empty_symbol, field_symbol_list, erroneous_symb } SymbKind; #if D STRUCT (state,State){ union { struct { StateKind arg_kind; /* for SimpleState */ ObjectKind arg_object; } state_arg; struct state * state_args; /* for TupleState and ArrayState */ struct record_state_descr * state_rs; /* for RecordState */ }; short state_arity; unsigned char state_type; /* StateType */ unsigned char state_mark; }; #define state_kind state_arg.arg_kind #define state_object state_arg.arg_object #define state_record_symbol state_rs->rs_symb #define state_record_arguments state_rs->rs_args #define state_record_desc state_rs #define state_tuple_arguments state_args #define state_array_arguments state_args #else STRUCT (state,State){ union { struct state * sd_args; /* for TupleState and ArrayState */ struct record_state_descr * sd_rs; /* for RecordState */ unsigned long sd_unq_type_args; /* for SimpleState with STATE_UNIQUE_TYPE_ARGUMENTS_MASK */ } state_descr; short state_arity; unsigned char state_kind:4; /* StateKind, for SimpleState */ unsigned char state_mark:4; unsigned char state_object:6; /* ObjectKind, for SimpleState */ unsigned char state_type:2; /* StateType */ }; #define state_unq_type_args state_descr.sd_unq_type_args #define STATE_UNIQUE_TYPE_ARGUMENTS_MASK 8 # define state_record_symbol state_descr.sd_rs->rs_symb # define state_record_arguments state_descr.sd_rs->rs_args # define state_record_desc state_descr.sd_rs # define state_tuple_arguments state_descr.sd_args # define state_array_arguments state_descr.sd_args #endif typedef struct state *States; #define STATE_PARALLEL_MASK 1 #define STATE_UNBOXED_ARRAY_MASK 2 /* for ArrayState */ #define STATE_ELEMENTS_UPDATEABLE_MASK 2 /* for TupleState */ #define STATE_UNIQUE_MASK 4 typedef struct record_state_descr { struct symbol_def * rs_symb; StateS rs_args[1]; } *RecordStateDescr; typedef enum { SymbolIdTable, TypeSymbolIdTable, TypeVarIdTable, ModuleIdTable, FieldIdTable, KeyWordTable, InternalIdTable } TableKind; typedef union symb_value { struct ident * val_ident; struct symbol_def * val_def; char * val_int; Bool val_bool; char * val_char; char * val_string; char * val_real; char * val_error_mess; int val_arity; struct symbol_type * val_type; /* for cons_symb, nil_symb apply_symbol ? */ struct symbol * val_symb; /* for field_symbol_list */ struct overloaded_instance * val_instance; } SymbValue; STRUCT (symbol,Symbol) { SymbValue symb_val; Symbol symb_next; unsigned symb_kind:8; /* SymbKind */ Bool symb_infix:1; unsigned symb_infix_priority:4; unsigned symb_infix_assoc:2; /* Assoc */ }; #if STRICT_LISTS # define symb_head_strictness symb_infix_priority /* 0=lazy,1=strict,2=unboxed */ # define symb_tail_strictness symb_infix_assoc /* 0=lazy,1=strict */ #endif #define symb_ident symb_val.val_ident #define symb_def symb_val.val_def #define symb_int symb_val.val_int #define symb_bool symb_val.val_bool #define symb_char symb_val.val_char #define symb_string symb_val.val_string #define symb_real symb_val.val_real #define symb_arity symb_val.val_arity #define symb_type symb_val.val_type #define symb_arrfun symb_val.val_arrfun #define symb_symb symb_val.val_symb #define symb_instance symb_val.val_instance #define symb_member symb_val.val_member #define symb_error_mess symb_val.val_error_mess STRUCT(ident,Ident){ char * ident_name; char * ident_environ; union{ Symbol ident_u1_symbol; struct node_id * ident_u1_nodeid; struct type_var * ident_u1_tv; struct uni_var * ident_u1_uni_var; char * ident_u1_instructions; } ident_union1; #ifdef SHORT_CLASS_NAMES union{ struct local_def * ident_u2_local_defs; struct module_info * ident_u2_mod_info; } ident_union2; #else struct local_def * ident_local_defs; #endif struct ident * ident_next; unsigned char ident_table; /* TableKind */ unsigned char ident_mark; }; #define ident_symbol ident_union1.ident_u1_symbol #define ident_nodeid ident_union1.ident_u1_nodeid #define ident_tv ident_union1.ident_u1_tv #define ident_uni_var ident_union1.ident_u1_uni_var #define ident_instructions ident_union1.ident_u1_instructions #ifdef SHORT_CLASS_NAMES #define ident_local_defs ident_union2.ident_u2_local_defs #define ident_mod_info ident_union2.ident_u2_mod_info #endif #define IMPORT_MASK 1 #define IMPORTED_MASK 2 #define BOUND_MASK 4 #define INLINE_MASK 8 #define IMPLICITLY_IMPORTED_MASK 16 #define ID_UNIVAR_MASK (1 << 5) #define ID_TYPEVAR_MASK (1 << 6) #define ID_CLASSVAR_MASK (1 << 7) /* The order in which the annotationkinds appear in the enum type determines their priority */ typedef enum { NoAnnot, StrictAnnot, /* parallel annotations: */ ContinueAnnot, ParallelAnnot, LazyParallelAnnot, InterleavedAnnot, LazyInterleavedAnnot, ProcessAnnot,ParallelAtAnnot, DeferAnnot, ContInterleavedAnnot, WaitAnnot, ParallelNFAnnot, InterleavedNFAnnot } Annotation; typedef enum { AssocNone=0, AssocLeft=1, AssocRight=2 } Assoc; typedef struct ident_string *IdentStringP; struct ident_string { IdentStringP left; IdentStringP right; Ident ident; char *string; }; typedef struct symb_list SymbElem,*SymbList; struct symb_list { IdentStringP slist_ident_string; SymbList slist_next; unsigned slist_line; }; typedef struct def_repr DefRepr,*DefMod; typedef struct import_list ImportElem,*ImportList; struct import_list { Symbol ilist_module; Bool ilist_all; unsigned ilist_line; SymbList ilist_symbs; DefMod ilist_def; ImportList ilist_next; }; typedef struct node_def *NodeDefs; typedef struct { short index_a; short index_b; } Index; struct _exp; #if D extern void error (void); #define UNION_FIELD(type,field,field_i,field_n)\ inline type const &field (void){ return field_i!=field_n ? error(),_##field : _##field; };\ inline type &field##_ (void){ field_i=field_n; return _##field; } #define UNION2(i,t1,f1,t2,f2)\ union {\ t1 _##f1;\ t2 _##f2;\ };\ UNION_FIELD(t1,f1,i,1);\ UNION_FIELD(t2,f2,i,2) #define UNION4(i,t1,f1,t2,f2,t3,f3,t4,f4)\ union {\ t1 _##f1;\ t2 _##f2;\ t3 _##f3;\ t4 _##f4;\ };\ UNION_FIELD(t1,f1,i,1);\ UNION_FIELD(t2,f2,i,2);\ UNION_FIELD(t3,f3,i,3);\ UNION_FIELD(t4,f4,i,4) STRUCT (node_id,NodeId){ private: unsigned int nid_u1:4; unsigned int nid_u2:4; unsigned int nid_u3:4; unsigned int nid_u4:4; unsigned int nid_u5:4; public: node_id (void) { nid_u1=0; nid_u2=0; nid_u3=0; nid_u4=0; nid_u5=0; }; Ident nid_ident; unsigned short nid_mark; unsigned short nid_mark2; int nid_refcount; int nid_number; UNION4 (nid_u1, struct node_id * ,nid_forward_node_id, struct type_cell * ,nid_type, Index ,nid_index, struct node_id_ref_count_list * ,nid_node_id_ref_count_element /* pattern_match: graph */ ); #define nid_forward_node_id nid_forward_node_id() #define nid_forward_node_id_ nid_forward_node_id_() #define nid_type nid_type() #define nid_type_ nid_type_() #define nid_index nid_index() #define nid_index_ nid_index_() #define nid_node_id_ref_count_element nid_node_id_ref_count_element() #define nid_node_id_ref_count_element_ nid_node_id_ref_count_element_() union { struct { union { struct node * s1_subst_node; struct node_id * s1_subst_node_id; struct reference_info * s1_ref_info; }; int s1_ref_count_copy; } nid_s1; StateS _nid_state; }; inline struct node *const &nid_subst_node (void){ return nid_u4!=1 ? error(),nid_s1.s1_subst_node : nid_s1.s1_subst_node; }; inline struct node * &nid_subst_node_ (void){ nid_u4=1; return nid_s1.s1_subst_node; } #define nid_subst_node nid_subst_node() #define nid_subst_node_ nid_subst_node_() inline struct node_id *const &nid_subst_node_id (void){ return (nid_u4!=2 || nid_u5!=1) ? error(),nid_s1.s1_subst_node_id : nid_s1.s1_subst_node_id; }; inline struct node_id * &nid_subst_node_id_ (void){ nid_u4=2; return nid_s1.s1_subst_node_id; } #define nid_subst_node_id nid_subst_node_id() #define nid_subst_node_id_ nid_subst_node_id_() inline struct reference_info *const &nid_ref_info (void){ return (nid_u4!=3 || nid_u5!=1) ? error(),nid_s1.s1_ref_info : nid_s1.s1_ref_info; }; inline struct reference_info * &nid_ref_info_ (void){ nid_u4=3; return nid_s1.s1_ref_info; } #define nid_reference_info nid_ref_info() #define nid_reference_info_ nid_ref_info_() inline int const &nid_ref_count_copy (void){ return nid_u5!=1 ? error(),nid_s1.s1_ref_count_copy : nid_s1.s1_ref_count_copy; }; inline int &nid_ref_count_copy_ (void){ nid_u5=1; return nid_s1.s1_ref_count_copy; } inline int &nid_ref_count_copy__ (void){ return nid_u5!=1 ? error(),nid_s1.s1_ref_count_copy : nid_s1.s1_ref_count_copy; }; #define nid_ref_count_copy nid_ref_count_copy() #define nid_ref_count_copy_ nid_ref_count_copy_() #define nid_ref_count_copy__ nid_ref_count_copy__() inline StateS const &nid_state (void){ return (nid_u4!=4 || nid_u5!=2) ? error(),_nid_state : _nid_state; }; inline StateS &nid_state_ (void){ nid_u4=4; nid_u5=2; return _nid_state; } inline StateS &nid_state__ (void){ return (nid_u4!=4 || nid_u5!=2) ? error(),_nid_state : _nid_state; }; #define nid_state nid_state() #define nid_state_ nid_state_() #define nid_state__ nid_state__() int nid_scope; struct node * nid_node; UNION2(nid_u2, struct _exp * ,nid_exp, struct node_id* ,nid_lhs_tuple_node_id ); #define nid_exp nid_exp() #define nid_exp_ nid_exp_() #define nid_lhs_tuple_node_id nid_lhs_tuple_node_id() #define nid_lhs_tuple_node_id_ nid_lhs_tuple_node_id_() UNION2(nid_u3, NodeDefs ,nid_node_def, /* only for rhs */ struct state * ,nid_lhs_state_p /* only for lhs */ ); #define nid_node_def nid_node_def() #define nid_node_def_ nid_node_def_() #define nid_lhs_state_p nid_lhs_state_p() #define nid_lhs_state_p_ nid_lhs_state_p_() }; #define nid_a_index nid_index.index_a /* codegen2,instructions */ #define nid_a_index_ nid_index_.index_a /* codegen2,instructions */ #define nid_b_index nid_index.index_b /* codegen2,instructions */ #define nid_b_index_ nid_index_.index_b /* codegen2,instructions */ #else STRUCT (node_id,NodeId){ Ident nid_ident; unsigned short nid_mark; unsigned short nid_mark2; int nid_refcount; int nid_number; union { struct node_id * inf2_forward_node_id; struct type_cell * inf2_type; Index inf2_index; int inf2_lazy_selector_ref_count; } nid_inf2; union { struct { union { struct node * u1_subst_node; struct node_id * u1_subst_node_id; struct reference_info * u1_ref_info; /* NodeDefs u1_nodedef; */ } s_u1; int s_ref_count_copy; } inf1_s; StateS inf1_state; } nid_inf1; int nid_scope; struct node * nid_node; union { struct _exp * u3_exp; struct node_id* u3_lhs_tuple_node_id; struct node_id_ref_count_list * u3_ref_count_element; /* pattern_match: graph */ } nid_u3; union { NodeDefs u4_node_def; /* only for rhs */ struct state * u4_lhs_state_p; /* only for lhs */ } nid_u4; }; #define nid_subst_node nid_inf1.inf1_s.s_u1.u1_subst_node /* macros */ #define nid_subst_node_id nid_inf1.inf1_s.s_u1.u1_subst_node_id /* macros */ #define nid_reference_info nid_inf1.inf1_s.s_u1.u1_ref_info /* refcountanal */ /* #define nid_node_def nid_inf1.inf1_s.s_u1.u1_nodedef ** buildtree,sa,statesgen,optimisations */ #define nid_ref_count_copy nid_inf1.inf1_s.s_ref_count_copy /* statesgen */ #define nid_state nid_inf1.inf1_state /* codegen2,instructions */ #define nid_type nid_inf2.inf2_type /* comparser,typechecker */ #define nid_forward_node_id nid_inf2.inf2_forward_node_id /* checker,transform */ #define nid_node_id_ref_count_element nid_u3.u3_ref_count_element /* pattern_match */ #define nid_node_id_ref_count_element_ nid_u3.u3_ref_count_element /* pattern_match */ #define nid_a_index nid_inf2.inf2_index.index_a /* codegen2,instructions */ #define nid_b_index nid_inf2.inf2_index.index_b /* codegen2,instructions */ #define nid_lazy_selector_ref_count nid_inf2.inf2_lazy_selector_ref_count/* statesgen */ #define nid_type_ nid_inf2.inf2_type /* comparser,typechecker */ #define nid_forward_node_id_ nid_inf2.inf2_forward_node_id /* checker,transform */ #define nid_a_index_ nid_inf2.inf2_index.index_a /* codegen2,instructions */ #define nid_b_index_ nid_inf2.inf2_index.index_b /* codegen2,instructions */ #define nid_exp nid_u3.u3_exp /* sa */ #define nid_lhs_tuple_node_id nid_u3.u3_lhs_tuple_node_id #define nid_node_def nid_u4.u4_node_def /* buildtree,sa,statesgen,optimisations */ #define nid_lhs_state_p nid_u4.u4_lhs_state_p #define nid_ref_count_copy_ nid_ref_count_copy #define nid_ref_count_copy__ nid_ref_count_copy #define nid_node_def_ nid_node_def #define nid_state_ nid_state #define nid_state__ nid_state #define nid_lhs_tuple_node_id_ nid_lhs_tuple_node_id #define nid_subst_node_ nid_subst_node #define nid_subst_node_id_ nid_subst_node_id #define nid_exp_ nid_exp #define nid_lhs_state_p_ nid_lhs_state_p #define nid_reference_info_ nid_reference_info #endif /* Masks for nid_mark */ #define SHARED_NODES_COLLECTED_MASK 1 #define NID_ALIAS_MASK 2 #define NID_ALIAS_MARK_MASK 4 #define NID_COUNTED_AND_USED_IN_INNER_SCOPE 8 #define NID_EXTRA_REFCOUNT_MASK 16 #define COPY_NODE_MASK 64 #define ON_A_CYCLE_MASK 128 #define NID_VERIFY_MASK 256 /* macros */ #define NID_THEN_ELSE_NON_LOCAL_NODE_ID 512 /* pattern_match */ #define NID_TYPE_CHECKED_MASK 1024 /* typechecker */ #define NID_TYPE_ATTRIBUTED_MASK 2048 /* typechecker */ #define NID_EXTRA_REFCOUNT_SUBTRACTED_MASK 4096 /* checker */ #define NID_STRICT_LHS_TUPLE_ELEMENT_MASK 8192 /* codegen1,codegen2 */ #define NID_SHARED_SELECTION_NODE_ID 16384 #define NID_LIFTED_BY_OPTIMISE 32768 /* optimisations */ /* Masks for nid_mark2 */ #define NID_HAS_REF_COUNT_INFO_MASK (1 << 0) /* refcountanal */ #define NID_DETERMINE_REF_COUNT_MASK (1 << 1) /* refcountanal */ #define NID_REF_COUNT_DETERMINED_MASK (1 << 2) /* refcountanal */ #define NID_LHS_ROOT_ID (1 << 3) /* refcountanal */ #define NID_READ_ONLY_ID (1 << 4) /* typechecker */ #define NID_FIELD_NAME_MASK (1 << 5) /* typechecker */ #define NID_COMPONENT_DETERMINED_MASK 256 /* optimise_lambda */ #define NID_LIFTED_CONSTANT_CHECKED_MASK 512 /* checker */ #define NID_LIFTED_MASK 1024 /* checker */ #define NID_REFERENCE_NOT_COUNTED_MASK 2048 /* checker */ #define NID_LHS_PUSHED 4096 /* codegen1 */ #define NID_HAS_LAZY_SELECTOR_COUNTER 8192 /* statesgen */ #define NID_CALL_VIA_LAZY_SELECTIONS_ONLY 16384 /* statesgen */ #define NID_HAS_REFCOUNT_WITHOUT_UPDATES 32768 typedef struct imp_rule *ImpRules; typedef struct rule_type *RuleTypes; STRUCT (strict_node_id,StrictNodeId){ union { NodeId val_node_id; /* if snid_kind==0 */ Ident val_ident; /* if snid_kind==1 */ } snid_val; struct strict_node_id * snid_next; unsigned snid_mark:8; #ifdef OBSERVE_ARRAY_SELECTS_IN_PATTERN unsigned snid_array_select_in_pattern:1; #endif }; #define STRICT_NODE_ID_IDENT_MASK 1 #define STRICT_NODE_ID_OBSERVE_MASK 2 #define snid_node_id snid_val.val_node_id #define snid_ident snid_val.val_ident STRUCT (if_node_contents,IfNodeContents){ NodeDefs if_then_node_defs; ImpRules if_then_rules; union { StrictNodeIdP u_strict_node_ids; struct poly_list * u_observer_list; struct node_id_ref_count_list * u_node_id_ref_counts; } if_then_u; NodeDefs if_else_node_defs; ImpRules if_else_rules; union { StrictNodeIdP u_strict_node_ids; struct poly_list * u_observer_list; struct node_id_ref_count_list * u_node_id_ref_counts; } if_else_u; int if_local_scope; }; #define if_then_strict_node_ids if_then_u.u_strict_node_ids #define if_else_strict_node_ids if_else_u.u_strict_node_ids #define if_then_observer_list if_then_u.u_observer_list #define if_else_observer_list if_else_u.u_observer_list #define node_then_node_id_ref_counts node_contents.contents_if->if_then_u.u_node_id_ref_counts #define node_else_node_id_ref_counts node_contents.contents_if->if_else_u.u_node_id_ref_counts typedef enum { IfNode, NormalNode, SelectorNode, NodeIdNode, UpdateNode, MatchNode, /* normal nodes */ RecordNode, IdentNode, ApplyNode, PrefixNode, ScopeNode, /* nodes in parser and checker */ IndirectionNode, /* nodes in optimise_lambda */ OverloadedNode, RecursionNode, UpdateNodeInTC, /* nodes in typechecker */ SwitchNode, CaseNode, DefaultNode, PushNode, GuardNode, TupleSelectorsNode, FillUniqueNode /* nodes in codegen */ } NodeKind; #define SELECTOR_U 2 #define SELECTOR_F 3 #define SELECTOR_L 4 #define SELECTOR_N 5 #ifdef TRANSFORM_PATTERNS_BEFORE_STRICTNESS_ANALYSIS STRUCT (case_node_contents,CaseNodeContents){ struct node_id_ref_count_list * case_node_id_ref_counts; StrictNodeIdP case_strict_node_ids; }; #endif STRUCT (node,Node){ union { struct if_node_contents * contents_if; Symbol contents_symbol; NodeId contents_node_id; Ident contents_ident; struct node * contents_node; struct node_id_list_element *contents_node_ids; #ifdef TRANSFORM_PATTERNS_BEFORE_STRICTNESS_ANALYSIS StrictNodeIdP contents_guard_strict_node_ids; #endif } node_contents; struct arg * node_arguments; union { StateS su_state; struct { union { Symbol u_record_symbol; /* comparser,checker */ struct symbol_type * u_type_info; /* typechecker */ struct recursive_call * u_recursive_call; /* typechecker */ struct overloaded_function *u_overloaded_application; /* typechecker */ } s_u; int s_line; /* size for PushNode */ } su_s; struct { struct node_def * u_node_defs; /* for CaseNode,DefaultNode and GuardNode */ #ifdef TRANSFORM_PATTERNS_BEFORE_STRICTNESS_ANALYSIS struct case_node_contents * u_case; #else struct node_id_ref_count_list * u_node_id_ref_counts; #endif } su_u; struct { struct node_def * scope_node_defs; struct imp_rule * scope_imp_rules; } su_scope; /* for ScopeNode */ } node_su; short node_arity; unsigned char node_kind; /* NodeKind */ signed char node_number:2; /* statesgen: -1,0 or 1,pattern_match ? */ Annotation node_annotation:6; }; #ifdef TRANSFORM_PATTERNS_BEFORE_STRICTNESS_ANALYSIS # define node_node_id_ref_counts node_su.su_u.u_case->case_node_id_ref_counts # define node_strict_node_ids node_su.su_u.u_case->case_strict_node_ids #else # define node_node_id_ref_counts node_su.su_u.u_node_id_ref_counts #endif #define node_state node_su.su_state #define node_record_symbol node_su.su_s.s_u.u_record_symbol #define node_type node_su.su_s.s_u.u_type_info #define node_recursive_call node_su.su_s.s_u.u_recursive_call #define node_overloaded_application node_su.su_s.s_u.u_overloaded_application #define node_line node_su.su_s.s_line #define node_node_defs node_su.su_u.u_node_defs #define node_symbol node_contents.contents_symbol #define node_node_id node_contents.contents_node_id #define node_ident node_contents.contents_ident #define node_node node_contents.contents_node #define node_node_ids node_contents.contents_node_ids #ifdef TRANSFORM_PATTERNS_BEFORE_STRICTNESS_ANALYSIS #define node_guard_strict_node_ids node_contents.contents_guard_strict_node_ids #endif #define node_then_node_defs node_contents.contents_if->if_then_node_defs #define node_then_rules node_contents.contents_if->if_then_rules #define node_then_strict_node_ids node_contents.contents_if->if_then_strict_node_ids #define node_else_node_defs node_contents.contents_if->if_else_node_defs #define node_else_rules node_contents.contents_if->if_else_rules #define node_else_strict_node_ids node_contents.contents_if->if_else_strict_node_ids #define node_if_scope node_contents.contents_if->if_local_scope #define node_scope_node_defs node_su.su_scope.scope_node_defs #define node_scope_imp_rules node_su.su_scope.scope_imp_rules #define node_then_observer_list node_contents.contents_if->if_then_observer_list #define node_else_observer_list node_contents.contents_if->if_else_observer_list STRUCT (arg,Arg){ Node arg_node; struct arg * arg_next; union { StateS u_state; unsigned long u_occurrence; /* OccurrenceKind */ } arg_u; }; typedef struct arg *Args; #define arg_state arg_u.u_state #define arg_occurrence arg_u.u_occurrence STRUCT (node_def,NodeDef){ union { NodeId u1_id; Node u1_pattern; } def_u1; Node def_node; NodeDefs def_next; int def_mark; }; #define def_id def_u1.u1_id #define def_pattern def_u1.u1_pattern #define NODE_DEF_HAS_LHS_PATTERN_MASK 1 #define NODE_DEF_NEW_SCOPE_MASK 2 #define NODE_DEF_NORMAL_SCOPE_MASK 4 #define NODE_DEF_MARKED 8 #define NODE_DEF_OBSERVE_MASK 16 #define NODE_DEF_SELECT_AND_REMOVE_MASK 32 typedef struct local_def { union { NodeId contents_node_id; /* ldef_node_id, if ldef_kind==0 */ Symbol contents_symbol; /* ldef_symbol, if ldef_kind==1 */ } ldef_contents; struct local_def * ldef_next; int ldef_scope; char ldef_kind; char ldef_lifted; } LocalDef,*LocalDefP; #define ldef_node_id ldef_contents.contents_node_id #define ldef_symbol ldef_contents.contents_symbol /* for implementing calls to C or the OS */ typedef struct parameter Parameter,*Parameters; struct parameter { union { NodeId val_node_id; /* if par_kind == 0 */ Ident val_ident; /* if par_kind == 1 */ } par_val; Ident par_loc; Parameters par_next; int par_kind; }; #define par_node_id par_val.val_node_id #define par_ident par_val.val_ident typedef struct instruction Instruction,*Instructions; struct instruction { char * instr_this; Instructions instr_next; }; STRUCT (code_block,CodeBlock){ Parameters co_parin; Parameters co_parout; Instructions co_instr; Bool co_is_abc_code; #ifdef CLEAN2 Bool co_is_inline; #endif }; typedef enum { Contractum, ExternalCall } RhsKind; typedef struct rule_alt *RuleAlts; STRUCT (rule_alt,RuleAlt){ Node alt_lhs_root; NodeDefs alt_lhs_defs; union { Node rhs_root; CodeBlock rhs_code; } alt_rhs; NodeDefs alt_rhs_defs; union { StrictNodeIdP u_alt_strict_node_ids; struct poly_list * u_alt_observer_list; } alt_u; struct lifted_node_id * alt_lifted_node_ids; ImpRules alt_local_imp_rules; RuleAlts alt_next; unsigned alt_line; BITVECT alt_used_arguments; #ifdef OS2 unsigned alt_kind:4; /* RhsKind */ #else unsigned alt_kind:3; /* RhsKind */ #endif Bool alt_write_access:1; Bool alt_may_fail:1; }; #define alt_rhs_root alt_rhs.rhs_root #define alt_rhs_code alt_rhs.rhs_code #define alt_strict_node_ids alt_u.u_alt_strict_node_ids #define alt_observer_list alt_u.u_alt_observer_list typedef struct macro Macro,*Macros; struct macro { RuleAlts macro_rule; Node macro_root; unsigned macro_line; Macros macro_next; }; typedef enum { NEWDEFINITION, ABSTYPE, TYPE, TYPESYN, DEFRULE, IMPRULE, CONSTRUCTOR, SYSRULE, MACRORULE, RECORDTYPE, FIELDSELECTOR, OVERLOADEDRULE, INSTANCE, CLASS, CLASSINSTANCE, CLASSLIST } SDefKind; #define SDefKindSize 5 #define DERIVEDRULE 16 typedef enum { Indefinite, CurrentlyChecked, TypeChecked, Predefined, Expanded, TotallyExpanded, ConvertingToState, ConvertedToState } CheckStatus; typedef enum { CreateArrayFun, ArraySelectFun, UnqArraySelectFun, ArrayUpdateFun, ArrayReplaceFun, ArraySizeFun, UnqArraySizeFun, _CreateArrayFun,_UnqArraySelectFun,_UnqArraySelectNextFun,_UnqArraySelectLastFun, _ArrayUpdateFun, NoArrayFun } ArrayFunKind; #define ArrayFunKindBitSize 4 #include "syntax_tree_types.h" STRUCT (imp_rule,ImpRule){ NodeP rule_root; RuleAlts rule_alts; struct type_alt * rule_type; StateP rule_state_p; ImpRules rule_next; union { struct depend_function *u_depend_functions; ImpRuleP u_next_changed_function; ImpRuleP u_next_used_function; ImpRuleP u_next_function_with_more_arguments; } rule_u; struct node * rule_lazy_call_node; #if STORE_STRICT_CALL_NODES struct node * rule_strict_call_node; struct node * rule_strict_call_node2; #endif unsigned rule_line; unsigned rule_mark; unsigned rule_ref_count; }; #define RULE_CHECKED_MASK 1 #define RULE_CAF_MASK 2 #define RULE_LAZY_CALL_NODE_MASK 4 #if STORE_STRICT_CALL_NODES # define RULE_STRICT_CALL_NODE_MASK 8 # define RULE_STRICT_CALL_NODE2_MASK 16 #endif #define RULE_HAS_VERSION_WITH_MORE_ARGUMENTS 32 #define RULE_UNBOXED_LAZY_CALL 64 #define RULE_INTERNAL_FUNCTION_MASK 128 #define RULE_LAMBDA_FUNCTION_MASK 256 #define RULE_HAS_REF_COUNT_MASK 512 #define RULE_CALL_VIA_LAZY_SELECTIONS_ONLY 1024 #define rule_depend_functions rule_u.u_depend_functions /* comparser,checker,macros */ #define rule_next_changed_function rule_u.u_next_changed_function /* optimisations */ #define rule_next_used_function rule_u.u_next_used_function /* optimisations */ #define rule_next_function_with_more_arguments rule_u.u_next_function_with_more_arguments /* statesgen */ STRUCT (symbol_def,SymbDef){ char *sdef_module; Ident sdef_ident; union { Types u_type; RuleTypes u_rule_type; SynTypes u_syn_type; AbsTypes u_abs_type; ImpRules u_rule; Macros u_macro; Overloaded u_overloaded; Instance u_instance; ClassDefinition u_class; ClassInstance u_class_instance; SymbolList u_class_symb_list; } sdef_u; union { struct symbol_type_info * sti_rule_type_info; struct symbol_type * sti_type_cons_info; unsigned long sti_class_instance_info; StateS typeinfo_record_state; struct { FieldList fieldinfo_sel_field; Node fieldinfo_sel_node; int fieldinfo_sel_field_number; } sdef_fieldinfo; struct constructor_list * typeinfo_constructor; /* for CONSTRUCTOR */ } sdef_typeinfo; unsigned sdef_number; unsigned sdef_ancestor; short sdef_arity; short sdef_cons_arity; short sdef_over_arity; unsigned short sdef_nr_of_lifted_nodeids; union { struct _fun * u3_sa_fun; /* sa.c */ unsigned u3_instantiation_depth; } sdef_u3; struct symbol_def * sdef_dcl_icl; /* to dcl if sdef_exported, to icl if sdef_main_dcl */ union { struct symbol_def * u1_next_scc; Symbol u1_subst_symbol; } sdef_u1; union { struct symbol_def * sdef_u2_parent; struct member_item * sdef_u2_class_members; /* struct symbol_def * sdef_u2_aliases; */ struct type_cons_repr * sdef_u2_type_cons_repr; struct symbol_def * sdef_u2_next_version; /* for IMPRULES */ } sdef_u2; unsigned sdef_line; int sdef_mark; Bool sdef_isused:1; Bool sdef_is_local_function:1; Bool sdef_is_instantiated:1; Bool sdef_no_sa:1; Bool sdef_explicitly_imported:1; Bool sdef_has_aliases:1; Bool sdef_attributed:1; Bool sdef_returnsnode:1; Bool sdef_calledwithrootnode:1; Bool sdef_has_inftype:1; Bool sdef_typable:1; Bool sdef_contains_freevars:1; Bool sdef_noncoercible:1; Bool sdef_unq_attributed:1; Bool sdef_is_cyclic:1; Bool sdef_is_redirection:1; Bool sdef_is_observing:1; Bool sdef_is_hyperstrict:1; Bool sdef_with_uniqueness_variables:1; Bool sdef_current_type_vars_mark:1; /* for TYPESYN */ Bool sdef_abstract_type_synonym:1; /* for TYPESYN */ Bool sdef_strict_constructor:1; /* for CONSTRUCTOR and RECORDTYPE */ Bool sdef_exported:1; Bool sdef_main_dcl:1; /* if in .dcl of main .icl */ Bool sdef_first_group_element:1; Bool sdef_infix:1; #ifdef OS2 int sdef_stupid_gcc; SDefKind sdef_kind:SDefKindSize; unsigned sdef_infix_priority:4; unsigned sdef_checkstatus:4; /* CheckStatus */ unsigned sdef_prop_status:4; /* CheckStatus */ unsigned sdef_arfun:ArrayFunKindBitSize; /* ArrayFunKind */ unsigned sdef_infix_assoc:2; /* Assoc */ #else unsigned sdef_kind:SDefKindSize; unsigned sdef_infix_priority:4; unsigned sdef_infix_assoc:2; /* Assoc */ unsigned sdef_checkstatus:3; /* CheckStatus */ unsigned sdef_prop_status:3; /* CheckStatus */ unsigned sdef_arfun:ArrayFunKindBitSize; /* ArrayFunKind */ #endif }; #define sdef_type sdef_u.u_type #define sdef_rule_type sdef_u.u_rule_type #define sdef_syn_type sdef_u.u_syn_type #define sdef_abs_type sdef_u.u_abs_type #define sdef_rule sdef_u.u_rule #define sdef_macro sdef_u.u_macro #define sdef_rc sdef_u.u_rc #define sdef_overloaded sdef_u.u_overloaded #define sdef_instance sdef_u.u_instance #define sdef_class_instance sdef_u.u_class_instance #define sdef_class_symb_list sdef_u.u_class_symb_list #define sdef_class sdef_u.u_class #define sdef_instantiation_depth sdef_u3.u3_instantiation_depth #define sdef_sa_fun sdef_u3.u3_sa_fun #define sdef_next_scc sdef_u1.u1_next_scc #define sdef_subst_symbol sdef_u1.u1_subst_symbol /* macros */ #define SDEF_USED_LAZILY_MASK 1 #define SDEF_USED_STRICTLY_MASK 2 #define SDEF_USED_CURRIED_MASK 4 #define SDEF_LOCAL_MACRO_FUNCTION_MASK 8 #define SDEF_NEXT_IMP_RULE_VERSION_MASK 32 #define SDEF_HAS_IMP_RULE_VERSIONS_MASK 64 #define SDEF_OPTIMISED_FUNCTION_MASK 128 /* some macros to reuse bit fields */ #define sdef_group_number sdef_ancestor #define sdef_has_instance_info sdef_used_as_instance #define sdef_parent sdef_u2.sdef_u2_parent #define sdef_class_members sdef_u2.sdef_u2_class_members #define sdef_aliases sdef_u2.sdef_u2_aliases #define sdef_type_cons_repr sdef_u2.sdef_u2_type_cons_repr #define sdef_next_version sdef_u2.sdef_u2_next_version #define sdef_constructor sdef_typeinfo.typeinfo_constructor #define sdef_rule_type_info sdef_typeinfo.sti_rule_type_info #define sdef_type_cons_info sdef_typeinfo.sti_type_cons_info #define sdef_class_instance_info sdef_typeinfo.sti_class_instance_info #define sdef_rule_cons_type_info sdef_rc->rc_type_info #define sdef_rule_cons_imprule sdef_rc->rc_imprule #define sdef_rule_cons_defrule sdef_rc->rc_defrule #define sdef_record_state sdef_typeinfo.typeinfo_record_state #define sdef_ar_fun_aps sdef_typeinfo.typeinfo_ar_fun_aps #define sdef_sel_field sdef_typeinfo.sdef_fieldinfo.fieldinfo_sel_field #define sdef_sel_node sdef_typeinfo.sdef_fieldinfo.fieldinfo_sel_node #define sdef_sel_field_number sdef_typeinfo.sdef_fieldinfo.fieldinfo_sel_field_number #if IMPORT_OBJ_AND_LIB struct string_list { char * sl_string; struct string_list *sl_next; }; #endif typedef struct { Symbol im_name; Symbol im_symbols; ImportList im_imports; Types im_types; SynTypes im_syn_types; ImpRules im_rules; Macros im_macros; struct symbol_def * im_start; Bool im_main; DefMod im_def_module; ClassDefinition im_classes; ClassInstance im_instances; #ifdef SHORT_CLASS_NAMES struct module_info * im_module_info; #endif #if IMPORT_OBJ_AND_LIB struct string_list * im_imported_objs; struct string_list * im_imported_libs; #endif #if WRITE_DCL_MODIFICATION_TIME FileTime im_modification_time; #endif } *ImpMod, ImpRepr; struct def_repr { Symbol dm_name; Symbol dm_symbols; ImportList dm_imports; ExportList dm_exports; Types dm_types; SynTypes dm_syn_types; AbsTypes dm_abs_types; RuleTypes dm_rules; Macros dm_macros; Bool dm_system_module; ClassDefinition dm_classes; ClassInstance dm_instances; #ifdef SHORT_CLASS_NAMES struct module_info * dm_module_info; #endif #if WRITE_DCL_MODIFICATION_TIME FileTime dm_modification_time; #endif };