int_value.h

LastWave

#ifdef NUMDOUBLE
#define Flt2Str(flt,str) sprintf(str,"%.16g",flt)
#else
#define Flt2Str(flt,str) sprintf(str,"%.8g",flt)
#endif

#define CastValue(value,type) ((type) (ValueOf(value)))

#define ARG_EO_GetField(arg) ((char *) (arg)[0])

#define ARG_EI_GetField(arg) ((char *) (arg)[0])
#define ARG_EI_GetPOptions(arg) ((unsigned long *) (arg)[1])

#define ARG_S_GetField(arg) ((char *) (arg)[0])
// #define ARG_S_SetField(arg,field) ((char *) (arg)[0])=(field)
#define ARG_S_SetField(arg,field) ((arg)[0])=(field)
#define ARG_S_GetFsiList(arg) ((FSIList *) (arg)[1])
// #define ARG_S_SetFsiList(arg,fsi) ((FSIList *) (arg)[1])=(fsi)
#define ARG_S_SetFsiList(arg,fsi) ((arg)[1])=(fsi)
#define ARG_S_GetRightType(arg) ((char *) (arg)[2])
#define ARG_S_GetRightFloat(arg) (*((LWFLOAT *) (arg)[3]))
#define ARG_S_GetRightValue(arg) (*((VALUE *) (arg)[4]))
#define ARG_S_GetEqual(arg) ((char *) (arg)[5])
#define ARG_S_GetResPValue(arg) ((VALUE *) (arg)[6])
// #define ARG_S_SetResValue(arg,val) (*((VALUE *) (arg)[6]) = (val))
#define ARG_S_SetResValue(arg,val) (*((VALUE *) (arg)[6]) = (val))
#define ARG_S_GetResPFloat(arg) ((LWFLOAT *) (arg)[7])
#define ARG_S_GetResPStr(arg) ((char **) (arg)[8])

#define ARG_G_GetField(arg) ((char *) (arg)[0])
// #define ARG_G_SetField(arg,field) ((char *) (arg)[0])=(field)
#define ARG_G_SetField(arg,field) ((arg)[0])=(field)
#define ARG_G_GetFsiList(arg) ((FSIList *) (arg)[1])
#define ARG_G_GetResPFloat(arg) ((arg)[2])
#define ARG_G_SetResFloat(arg,flt) (*((LWFLOAT *) (arg)[2]) = (flt))
#define ARG_G_GetResPStr(arg) ((arg)[3])
#define ARG_G_SetResStr(arg,str) (*((char **) (arg)[3]) = (str))
#define ARG_G_GetResPValue(arg) ((arg)[4])
#define ARG_G_SetResValue(arg,val) (*((VALUE *) (arg)[4]) = (VALUE) (val))

#define ARG_NE_GetResPValue(arg) ((arg)[4])
#define ARG_NE_GetN(arg) ((int) *((LWFLOAT *) (arg)[0]))
#define ARG_NE_GetFlagDot(arg) (*((char *) (arg)[1]))
#define ARG_NE_SetResValue(arg,val) (*((VALUE *) (arg)[4]) = (VALUE) (val))

/************************************************************
 *
 *
 *  basic VALUE types
 *
 *
 ************************************************************/


/***********************
 *
 * The 'null' value 
 *
 ***********************/
extern VALUE NewNullValue(void);
extern VALUE nullValue;
extern char *nullType;


/***********************
 *
 * The STRVALUE 
 *
 ***********************/
 
typedef struct strValue {

  /* The fields of VALUE */ 
  ValueFields;

  char *str; /* the string */
  char **list;  /* the eventual associated list */

} StrValue, *STRVALUE;
 
extern char * strType;
extern char * listType;
extern TypeStruct tsStr;

/* The minimum size of a string (should be greater than what is needed to represent a number) */
#define MinStringSize 30 

/* (des)allocation */
extern void DeleteStrValue(STRVALUE sc);
extern void InitNullStrValue(STRVALUE sc);
extern void InitStrValue(STRVALUE sc);
extern char * StrValueStrAlloc(int n);
extern STRVALUE NewNullStrValue(void);
extern STRVALUE NewStrValue(void);
extern STRVALUE TNewStrValue(void);

/* Routins to Get/Set string fields */
extern void *SetStrField(char **pstr, void **arg);
extern void *GetStrField(char *str, void **arg);

/* Simple operations */
extern void CopyStrValue(STRVALUE in, STRVALUE out);
extern void ConcatStrValue(STRVALUE sc1,STRVALUE sc2,STRVALUE sc3);
extern void MultStrValue(STRVALUE sc1, int n, STRVALUE sc3);

extern char *GetStrFromStrValue(STRVALUE sc);
extern char **GetListFromStrValue(STRVALUE sc);
extern void SetStrValue(STRVALUE sc, char *str);

/* Managing Variables */
struct level;
extern char * GetStrVariableLevel(struct level *level,char *name);
extern char * GetStrVariable(char *name);
extern void SetStrVariableLevel(struct level * level,char *name,char *value);
extern void SetStrVariable(char *name,char *value);
extern void SetStrVariablef(char *name,char *format, ...);
extern void SetStrVariableListLevel(struct level *level,char *name,char **list, char flagBracket);
extern void SetStrVariableList(char *name,char **list, char flagBracket);


/* Managing regexp */
extern char MatchStr(char *str,char *expr);
extern struct listvValue  *MatchStrN(char *str,char *expr, int nOcc);

/* Basic routines on strings */
extern void DeleteStr(char *str);
extern char *CopyStr(char *str);
extern char *TCopyStr(char *str);
extern void TempStr(char *str);
extern void PrintStrColumn(char *str,int size);

/* Basic routines on lists */
extern void DeleteList(char **list);
extern char **CopyList(char **list);
extern char **TCopyList(char **list);
extern char **Array2List(char **array, int nElem);
extern char **TArray2List(char **array, int nElem);
extern char *List2Str(char **list,char *separator);
extern char *TList2Str(char **list,char *separator);
extern char **Str2List(char *str,...);
extern char **TStr2List(char *str,...);
extern char **BegEndStr2List(char *begStr[],char *endStr[]);
extern char **TBegEndStr2List(char *begStr[],char *endStr[]);
extern char IsList(char *str);
extern int GetListSize(char **list);


/***********************
 *
 * The NUMVALUE 
 *
 ***********************/

/* 
 * The structure of a num variable content
 */
typedef struct numValue {

  /* The fields of VALUE */ 
  ValueFields;

  LWFLOAT f; /* the LWFLOAT */

} NumValue, *NUMVALUE;
 
extern char * numType;
extern char * intType;
extern char * floatType;
extern TypeStruct tsNum;


extern void DeleteNumValue(NUMVALUE nc);
extern void InitNumValue(NUMVALUE nc);
extern NUMVALUE NewNumValue(void);
extern NUMVALUE TNewNumValue(void);
extern void CopyNumValue(NUMVALUE in, NUMVALUE out);

extern void SetNumValue(NUMVALUE nc, LWFLOAT value);

extern int GetIntVariableLevel(struct level * level,char *name);
extern int GetIntVariable(char *name);
extern LWFLOAT GetFloatVariableLevel(struct level * level,char *name);
extern LWFLOAT GetFloatVariable(char *name);
extern void SetNumVariableLevel(struct level * level,char *name,LWFLOAT value);
extern void SetNumVariable(char *name,LWFLOAT value);


/* Functions to Get/Set number fields of objects */
#define FieldPositive 1
#define FieldSPositive 2
#define FieldNegative 3
#define FieldSNegative 4
extern void *SetFloatField(LWFLOAT *pflt, void **arg, char flag);
extern void *SetIntField(int *pint, void **arg,char flag);
extern void *GetFloatField(LWFLOAT f, void **arg);
extern void *GetIntField(int i, void **arg);


/***********************
 *
 * The LISTV 
 *
 ***********************/


typedef struct listvValue {

  /* The fields of VALUE */ 
  ValueFields;

  int nAlloc;             /* The allocated number of elements */
  int length;             /* The effective number of elements */
  LWFLOAT *f;               /* LWFLOAT elements */
  VALUE *values;              /* the value elements (when an element is NULL then it means that we should look into f[] */

} * LISTV;

/* The corresponding type name */
extern char *listvType;
extern TypeStruct tsListv;

extern LISTV NewListv(void);
extern LISTV TNewListv(void);
extern void DeleteListv(LISTV lv);
extern void SetLengthListv(LISTV lv, int length);
extern void ClearListv(LISTV lv);

extern char *GetListvNth(LISTV lv,int i,VALUE *vc,LWFLOAT *f);
extern char *GetListvNthStr(LISTV lv,int i);
extern LWFLOAT GetListvNthFloat(LISTV lv,int n);

extern void SetListvNthFloat(LISTV lv,int n,LWFLOAT f);
extern void SetListvNthValue(LISTV lv,int n,VALUE vc);

extern void *SetListvField(LISTV *plv,void **arg);

extern int AreEqualListv(LISTV lv1,LISTV lv2);

extern LISTV CopyListv(LISTV in,LISTV out);
extern void ConcatListv(LISTV lv1,LISTV lv2,LISTV lv3);
extern void MultListv(LISTV lv1, int n, LISTV l3);

extern void AppendValue2Listv (LISTV lv, VALUE vc);
extern void AppendFloat2Listv (LISTV lv, LWFLOAT f);
extern void AppendFloatArray2Listv (LISTV lv, LWFLOAT *f, int n);
extern void AppendInt2Listv (LISTV lv, int i);
extern void AppendIntArray2Listv (LISTV lv, int *i, int n);
extern void AppendStr2Listv (LISTV lv, char *str);
extern void AppendStr2Listvf(LISTV lv, char *format,...);
extern void AppendListv2Listv (LISTV lv, LISTV lv1);


/* 
 * The structure of a range variable content
 *   It should start with the fields of VALUE
 */

typedef struct rangeValue {

  /* The fields of VALUE */ 
  ValueFields;

  LWFLOAT first,step;
  int size;

} * RANGE;

/* The corresponding type name */
extern char *rangeType;
extern TypeStruct tsRange;

extern RANGE NewRange(void);
extern RANGE TNewRange(void);
extern void DeleteRange(RANGE r);

#define RangeVal(r,i) ((r)->step*(i)+(r)->first)
#define RangeLast(r) (RangeVal((r),(r)->size-1))
#define RangeFirst(r) ((r)->first)
#define RangeMax(r) ((r)->step>0 ? RangeLast(r) : RangeFirst(r))
#define RangeMin(r) ((r)->step>0 ? RangeFirst(r) : RangeLast(r))



#endif