(* m2statement.def definition module for m2statement.cc.

Copyright (C) 2011-2025 Free Software Foundation, Inc.
Contributed by Gaius Mulley <gaius.mulley@southwales.ac.uk>.

This file is part of GNU Modula-2.

GNU Modula-2 is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.

GNU Modula-2 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
along with GNU Modula-2; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  *)

DEFINITION MODULE FOR "C" m2statement ;

FROM gcctypes IMPORT location_t, tree ;
FROM CDataTypes IMPORT CharStar ;
FROM m2expr IMPORT BuildUnarySetFunction ;


(*
   DoJump - jump to the appropriate label depending whether
            result of the expression is TRUE or FALSE.
*)

PROCEDURE DoJump (location: location_t; exp: tree; falselabel, truelabel: CharStar) ;


(*
   BuildStartFunctionCode - generate function entry code.
*)

PROCEDURE BuildStartFunctionCode (location: location_t; fndecl: tree; isexported: BOOLEAN; isinline: BOOLEAN) ;


(*
   BuildEndFunctionCode - generates the function epilogue.
*)

PROCEDURE BuildEndFunctionCode (location: location_t; fndecl: tree; nested: BOOLEAN) ;


(*
   BuildReturnValueCode - generates the code associated with: RETURN( value )
*)

PROCEDURE BuildReturnValueCode (location: location_t; fndecl: tree; value: tree) ;


(*
   BuildPushFunctionContext - pushes the current function context.
                              Maps onto push_function_context in ../function.c
*)

PROCEDURE BuildPushFunctionContext ;


(*
   BuildPopFunctionContext - pops the current function context.
                             Maps onto pop_function_context in ../function.c
*)

PROCEDURE BuildPopFunctionContext ;


(*
   BuildAssignmentTree - builds the assignment of, des, and, expr.
                         It returns, des.
*)

PROCEDURE BuildAssignmentTree (location: location_t; des, expr: tree) : tree ;


(*
   BuildAssignmentStatement builds the assignment of, des, and, expr.
*)

PROCEDURE BuildAssignmentStatement (location: location_t; des, expr: tree) ;


(*
   BuildGoto - builds a goto operation.
*)

PROCEDURE BuildGoto (location: location_t; name: CharStar) ;


(*
   DeclareLabel - create a label, name.
*)

PROCEDURE DeclareLabel (location: location_t; name: CharStar) ;


(*
   BuildIfThenDoEnd - returns a tree which will only execute
                      statement, s, if, condition, is true.
*)

PROCEDURE BuildIfThenDoEnd (condition: tree; then_block: tree) : tree ;


(*
   BuildIfThenElseEnd - returns a tree which will execute
                        then_block or else_block depending upon,
                        condition.
*)

PROCEDURE BuildIfThenElseEnd (condition: tree; then_block: tree; else_block: tree) : tree ;


(*
   BuildParam - build a list of parameters, ready for a subsequent procedure call.
*)

PROCEDURE BuildParam (location: location_t; param: tree) ;


(*
   BuildFunctionCallTree - creates a procedure function call from
                           a procedure and parameter list and the
                           return type, rettype.  No tree is returned
                           as the tree is held in the last_function
                           global variable.  It is expected the
                           BuildFunctValue is to be called after
                           a call to BuildFunctionCallTree.
*)

PROCEDURE BuildFunctionCallTree (location: location_t; procedure: tree; rettype: tree) ;


(*
   BuildProcedureCallTree - creates a procedure call from a procedure and
                            parameter list and the return type, rettype.
*)

PROCEDURE BuildProcedureCallTree (location: location_t; procedure: tree; rettype: tree) : tree ;


(*
   BuildIndirectProcedureCallTree - creates a procedure call from a procedure and
                                    parameter list and the return type, rettype.
*)

PROCEDURE BuildIndirectProcedureCallTree (location: location_t; procedure: tree; rettype: tree) : tree ;


(*
   BuildFunctValue - generates code for value := last_function(foobar);
*)

PROCEDURE BuildFunctValue (location: location_t; value: tree) : tree ;


(*
   BuildCall2 - builds a tree representing:  function(arg1, arg2).
*)

PROCEDURE BuildCall2 (location: location_t;
                      function, rettype, arg1, arg2: tree) : tree ;


(*
   BuildCall3 - builds a tree representing:  function(arg1, arg2, arg3).
*)

PROCEDURE BuildCall3 (location: location_t;
                      function, rettype, arg1, arg2, arg3: tree) : tree ;


(*
   SetLastFunction - set the last_function to, t.
*)

PROCEDURE SetLastFunction (t: tree) ;


(*
   GetLastFunction - returns, last_function.
*)

PROCEDURE GetLastFunction () : tree ;


(*
   GetParamTree - return parameter, i.
*)

PROCEDURE GetParamTree (call: tree; i: CARDINAL) : tree ;


(*
   BuildTryFinally - returns a TRY_FINALL_EXPR with the call and cleanups
                     attached.
*)

PROCEDURE BuildTryFinally (location: location_t; call: tree; cleanups: tree) : tree ;


(*
   BuildCleanUp - return a CLEANUP_POINT_EXPR which will clobber, param.
*)

PROCEDURE BuildCleanUp (param: tree) : tree ;


(*
    BuildAsm - generates an inline assembler instruction.
*)

PROCEDURE BuildAsm (location: location_t; instr: tree;
                    isVolatile: BOOLEAN; isSimple: BOOLEAN;
                    inputs: tree; outputs: tree; trash: tree; labels: tree) ;


(*
    BuildUnaryForeachWordDo - provides the large set operators.
                              Each word (or less) of the set can be
                              calculated by unop.
                              This procedure iterates over each word
                              of the large set invoking the unop.
*)

PROCEDURE BuildUnaryForeachWordDo (location: location_t; type: tree; op1: tree; op2: tree;
                                   unop: BuildUnarySetFunction;
                                   is_op1lvalue, is_op2lvalue, is_op1const, is_op2const: BOOLEAN) ;


(*
    BuildExcludeVarConst - builds the EXCL(op1, 1<<op2) operation for a small sets. Large
                           sets call this routine to exclude the bit in the particular word.
                           op2 is a constant.
*)

PROCEDURE BuildExcludeVarConst (location: location_t; type: tree; op1: tree; op2: tree; is_lvalue: BOOLEAN; fieldno: INTEGER) ;


(*
    BuildExcludeVarVar - builds the EXCL(varset, 1<<varel) operation for a small and large sets.
                         varel is a variable.
*)

PROCEDURE BuildExcludeVarVar (location: location_t; type: tree; varset: tree; varel: tree; is_lvalue: BOOLEAN; low: tree) ;


(*
    BuildIncludeVarConst - builds the INCL(op1, 1<<op2) operation for a small sets. Large
                           sets call this routine to include the bit in the particular word.
                           op2 is a constant.
*)

PROCEDURE BuildIncludeVarConst (location: location_t; type: tree; op1: tree; op2: tree; is_lvalue: BOOLEAN; fieldno: INTEGER) ;


(*
    BuildIncludeVarVar - builds the INCL(varset, 1<<varel) operation for a small and large sets.
                         op2 is a variable.
*)

PROCEDURE BuildIncludeVarVar (location: location_t; type: tree; varset: tree; varel: tree; is_lvalue: BOOLEAN; low: tree) ;


(*
    BuildStart - creates a module initialization function. We make
                 this function public if it is not an inner module.
                 The linker will create a call list for all linked
                 modules which determines the initialization
                 sequence for all modules.
*)

PROCEDURE BuildStart (location: location_t; name: CharStar; inner_module: BOOLEAN) : tree ;


(*
    BuildEnd - complete the initialisation function for this module.
*)

PROCEDURE BuildEnd (location: location_t; fndecl: tree; nested: BOOLEAN) ;


(*
    BuildCallInner - call the inner module function.  It has no parameters and no return value.
*)

PROCEDURE BuildCallInner (location: location_t; fndecl: tree) ;


(*
   SetBeginLocation - sets the begin location for the function to obtain good debugging info.
*)

PROCEDURE SetBeginLocation (location: location_t) ;


(*
   SetEndLocation - sets the end location for the function to obtain good debugging info.
*)

PROCEDURE SetEndLocation (location: location_t) ;


(*
   BuildBuiltinCallTree - calls the builtin procedure.
*)

PROCEDURE BuildBuiltinCallTree (func: tree) : tree ;


(*
   CopyByField - copy expr to des, if des is a record, union or an array
                 then check fields for GCC type equivalence and if necessary
                 call __builtin_strncpy and __builtin_memcpy.
                 This can occur if an expr contains a constant string
                 which is to be assigned into a field declared as
                 an ARRAY [0..n] OF CHAR.
*)

PROCEDURE CopyByField (location: location_t; des, expr: tree) ;


END m2statement.