Logo Search packages:      
Sourcecode: felt version File versions  Download package

write.c

/*
    This file is part of the FElt finite element analysis package.
    Copyright (C) 1993-2000 Jason I. Gobat and Darren C. Atkinson

    This program 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 2 of the License, or
    (at your option) any later version.

    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
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

/************************************************************************
 * File:    write.c                                         *
 *                                                    *
 * Description:   This file contains the function definitions for the   *
 *          write and writes intrinsic functions.                 *
 ************************************************************************/

# include <ctype.h>
# include "felt.h"
# include "write.h"
# include "coerce.h"
# include "execute.h"
# include "functab.h"
# include "writetab.h"


/************************************************************************
 * Function:      write_null                                *
 *                                                    *
 * Description:   Writes a null descriptor.                       *
 ************************************************************************/

static void write_null (d)
    descriptor *d;
{
    printf ("null");
}


/************************************************************************
 * Function:      write_variable                                  *
 *                                                    *
 * Description:   Writes a variable descriptor.                   *
 ************************************************************************/

static void write_variable (d)
    descriptor *d;
{
    d = deref (d);
    writetab [D_Type (d)] (d);
}


/************************************************************************
 * Function:      write_function                                  *
 *                                                    *
 * Description:   Writes a function descriptor.                   *
 ************************************************************************/

static void write_function (d)
    descriptor *d;
{
    int      i;
    Function func;


    func = D_Function (d);
    printf ("%s(", func -> name);

    for (i = 0; i < func -> num_args; i ++)
      printf ("%s%c", i ? "," : "", 'a' + i);

    printf (")");
}


/************************************************************************
 * Function:      write_intrinsic                                 *
 *                                                    *
 * Description:   Writes an intrinsic function descriptor.        *
 ************************************************************************/

static void write_intrinsic (d)
    descriptor *d;
{
    int i;
    int nargs;
    int index;


    index = D_Intrinsic (d);
    nargs = functab [index].num_args;

    printf ("%s(", functab [index].name);

    if (nargs < 0)
      printf ("...");
    else
      for (i = 0; i < nargs; i ++)
          printf ("%s%c", i ? "," : "", 'a' + i);

    printf (")");
}


/************************************************************************
 * Function:      write_string                                    *
 *                                                    *
 * Description:   Writes a string descriptor.                     *
 ************************************************************************/

static void write_string (d)
    descriptor *d;
{
    printf ("%s", *D_String (d) ? *D_String (d) : "(null)");
}


/************************************************************************
 * Function:      write_double                                    *
 *                                                    *
 * Description:   Writes a double descriptor.                     *
 ************************************************************************/

static void write_double (d)
    descriptor *d;
{
    printf ("%g", *D_Double (d));
}


/************************************************************************
 * Function:      write_int                                 *
 *                                                    *
 * Description:   Writes an integer descriptor.                   *
 ************************************************************************/

static void write_int (d)
    descriptor *d;
{
    printf ("%d", *D_Int (d));
}


/************************************************************************
 * Function:      write_byte                                *
 *                                                    *
 * Description:   Writes a byte descriptor.                       *
 ************************************************************************/

static void write_byte (d)
    descriptor *d;
{
    printf (iscntrl (*D_Byte (d)) ? "%d" : "%c", *D_Byte (d));
}


/************************************************************************
 * Function:      write_array                               *
 *                                                    *
 * Description:   Writes an array descriptor.                     *
 ************************************************************************/

static void write_array (d)
    descriptor *d;
{
    printf ("array of %s", type_names [D_Array (d) -> type]);
}


/************************************************************************
 * Function:      write_row                                 *
 *                                                    *
 * Description:   Writes a row descriptor.                        *
 ************************************************************************/

static void write_row (d)
    descriptor *d;
{
    printf ("row");
}


/************************************************************************
 * Function:      write_matrix                                    *
 *                                                    *
 * Description:   Writes a matrix descriptor.                     *
 ************************************************************************/

static void write_matrix (d)
    descriptor *d;
{
    PrintMatrix (D_Matrix (d), stdout);
}


/************************************************************************
 * Function:      write_matrix_ptr                          *
 *                                                    *
 * Description:   Writes a matrix_ptr descriptor.                       *
 ************************************************************************/

static void write_matrix_ptr (d)
    descriptor *d;
{
    printf ("matrixptr");
}


/************************************************************************
 * Function:      write_analysis                                  *
 *                                                    *
 * Description:   Writes an analysis descriptor.                        *
 ************************************************************************/

static void write_analysis (d)
    descriptor *d;
{
    printf ("analysis parameters");
}


/************************************************************************
 * Function:      write_constraint                          *
 *                                                    *
 * Description:   Writes a constraint descriptor.                       *
 ************************************************************************/

static void write_constraint (d)
    descriptor *d;
{
    Constraint c;


    c = *D_Constraint (d);
    printf ("constraint (%s)", c ? c -> name : "null");
}


/************************************************************************
 * Function:      write_definition                          *
 *                                                    *
 * Description:   Writes a definition descriptor.                       *
 ************************************************************************/

static void write_definition (d)
    descriptor *d;
{
    Definition def;


    def = *D_Definition (d);
    printf ("definition (%s)", def ? def -> name : "null");
}


/************************************************************************
 * Function:      write_element                                   *
 *                                                    *
 * Description:   Writes an element descriptor.                   *
 ************************************************************************/

static void write_element (d)
    descriptor *d;
{
    Element e;


    e = *D_Element (d);
    printf (e ? "element (%u)" : "element (null)", e ? e -> number : 0);
}


/************************************************************************
 * Function:      write_force                               *
 *                                                    *
 * Description:   Writes a force descriptor.                      *
 ************************************************************************/

static void write_force (d)
    descriptor *d;
{
    Force f;


    f = *D_Force (d);
    printf ("force (%s)", f ? f -> name : "null");
}


/************************************************************************
 * Function:      write_load                                *
 *                                                    *
 * Description:   Writes a load descriptor.                       *
 ************************************************************************/

static void write_load (d)
    descriptor *d;
{
    Distributed l;


    l = *D_Load (d);
    printf ("load (%s)", l ? l -> name : "null");
}


/************************************************************************
 * Function:      write_material                                  *
 *                                                    *
 * Description:   Writes a material descriptor.                   *
 ************************************************************************/

static void write_material (d)
    descriptor *d;
{
    Material m;


    m = *D_Material (d);
    printf ("material (%s)", m ? m -> name : "null");
}


/************************************************************************
 * Function:      write_node                                *
 *                                                    *
 * Description:   Writes a node descriptor.                       *
 ************************************************************************/

static void write_node (d)
    descriptor *d;
{
    Node n;


    n = *D_Node (d);
    printf (n ? "node (%u)" : "node (null)", n ? n -> number : 0);
}


/************************************************************************
 * Function:      write_pair                                *
 *                                                    *
 * Description:   Writes a pair descriptor.                       *
 ************************************************************************/

static void write_pair (d)
    descriptor *d;
{
    Pair *p;


    p = D_Pair (d);
    printf ("pair (%u,%g)", p -> node, p -> magnitude);
}


/************************************************************************
 * Function:      write_problem                                   *
 *                                                    *
 * Description:   Writes a problem descriptor.                    *
 ************************************************************************/

static void write_problem (d)
    descriptor *d;
{
    printf ("problem definition");
}


/************************************************************************
 * Function:      write_stress                                    *
 *                                                    *
 * Description:   Writes a stress descriptor.                     *
 ************************************************************************/

static void write_stress (d)
    descriptor *d;
{
    printf ("stress");
}


/************************************************************************
 * Function:      write_external                                  *
 *                                                    *
 * Description:   Writes an external descriptor.                        *
 ************************************************************************/

static void write_external (d)
    descriptor *d;
{
    printf ("external C function (%p)", *D_External (d));
}


/************************************************************************
 * Function:      write_func                                *
 *                                                    *
 * Description:   Writes a list of descriptors followed by a new line.  *
 *          The result of the function is always zero.            *
 ************************************************************************/

int write_func (n)
    int n;
{
    int           i;
    descriptor *d;


    d = NULL;

    for (i = n - 1; i >= 0; i --) {
      d = ntop (i);
      d = deref (d);
      d = CollapseArray (d);

      writetab [D_Type (d)] (d);
      RecycleData (d);
    }

    if (d && D_Type (d) != T_Matrix)
      printf ("\n");

    for (i = 0; i < n; i ++)
      pop ( );

    d = push ( );
    D_Type    (d) = T_Double;
    D_Temp    (d) = F_False;
    D_Trapped (d) = F_False;
    D_Double  (d) = dbllit (0);
    return 0;
}


/************************************************************************
 * Function:      writes_func                               *
 *                                                    *
 * Description:   Writes a list of descriptors.  The result of the      *
 *          function is always zero.                        *
 ************************************************************************/

int writes_func (n)
    int n;
{
    int           i;
    descriptor *d;


    d = NULL;

    for (i = n - 1; i >= 0; i --) {
      d = ntop (i);
      d = deref (d);
      d = CollapseArray (d);

      writetab [D_Type (d)] (d);
      RecycleData (d);
    }

    for (i = 0; i < n; i ++)
      pop ( );

    d = push ( );
    D_Type    (d) = T_Double;
    D_Temp    (d) = F_False;
    D_Trapped (d) = F_False;
    D_Double  (d) = dbllit (0);
    return 0;
}

Generated by  Doxygen 1.6.0   Back to index