Jabber WindowGram Client (JWGC)

Introduction Screenshots Installation Downloads
Documentation Browse Source Resources Project Site

Stable Version
-none-

Latest Version
beta5



Main Page | Alphabetical List | Data Structures | Directories | File List | Data Fields | Globals

eval.c File Reference

#include "mit-copyright.h"
#include "node.h"
#include "eval.h"
#include "substitute.h"
#include "port.h"
#include "buffer.h"
#include "regexp.h"
#include "text_operations.h"
#include "main.h"
#include "variables.h"

Go to the source code of this file.

Defines

#define string_to_bool(str)   (!strcasecmp(str,"true"))

Functions

int eval_bool_expr (Node *expr)
string eval_expr (Node *expr)


Define Documentation

#define string_to_bool str   )     (!strcasecmp(str,"true"))
 

Definition at line 42 of file eval.c.

Referenced by eval_bool_expr(), and eval_expr().


Function Documentation

int eval_bool_expr Node expr  ) 
 

Definition at line 71 of file eval.c.

References eval_expr(), Node, string, and string_to_bool.

00073 {
00074         string temp;
00075         int result;
00076 
00077         if (!expr)
00078                 return (1);
00079 
00080         temp = eval_expr(expr);
00081         result = string_to_bool(temp);
00082         free(temp);
00083 
00084         return (result);
00085 }

string eval_expr Node expr  ) 
 

Definition at line 103 of file eval.c.

References AND_OPCODE, BUFFER_OPCODE, buffer_to_string(), dEval, DOWNCASE_OPCODE, dprintf(), ed_regexp_match_p(), EQ_OPCODE, eval_expr(), GET_OPCODE, getenv(), GETENV_OPCODE, JVAR_OPCODE, jVars_get(), jVars_stoi(), lany(), LANY_OPCODE, lbreak(), LBREAK_OPCODE, lspan(), LSPAN_OPCODE, NEQ_OPCODE, Node, NOT_OPCODE, OR_OPCODE, paragraph(), PARAGRAPH_OPCODE, PLUS_OPCODE, protect(), PROTECT_OPCODE, rany(), RANY_OPCODE, rbreak(), RBREAK_OPCODE, read_from_port(), REGEQ_OPCODE, REGNEQ_OPCODE, rspan(), RSPAN_OPCODE, string, string_Concat, STRING_CONSTANT_OPCODE, string_Copy, string_Downcase(), string_Eq, string_Neq, string_to_bool, string_to_character_class(), string_Upcase(), substitute(), SUBSTITUTE_OPCODE, UPCASE_OPCODE, var_get_variable(), var_set_variable(), VARREF_OPCODE, verbatim(), and VERBATIM_OPCODE.

00105 {
00106         int opcode = expr->opcode;
00107         int bool_result = 0;
00108         string first, second;
00109         char *result = 0;
00110         string *text_ptr;
00111         char *getenv();         /* UNIX get environment variable function */
00112 
00113         dprintf(dEval, "Eval Opcode %d\n", opcode);
00114 
00115         /*
00116          * Dispatch based on the opcode of the top node in the expression:
00117          */
00118         switch (opcode) {
00119                 case STRING_CONSTANT_OPCODE:
00120                         return (string_Copy(expr->d.string_constant));
00121 
00122                 case VARREF_OPCODE:
00123                         return (string_Copy(var_get_variable(expr->d.string_constant)));
00124 
00125                 case BUFFER_OPCODE:
00126                         return (string_Copy(buffer_to_string()));
00127 
00128                         /*
00129                          * Handle unary expressions:
00130                          */
00131                 case NOT_OPCODE:
00132                 case SUBSTITUTE_OPCODE:
00133                 case PROTECT_OPCODE:
00134                 case VERBATIM_OPCODE:
00135                 case GETENV_OPCODE:
00136                 case UPCASE_OPCODE:
00137                 case DOWNCASE_OPCODE:
00138                 case JVAR_OPCODE:
00139                 case GET_OPCODE:
00140                         first = eval_expr(expr->d.nodes.first);
00141 
00142                         switch (opcode) {
00143                                 case NOT_OPCODE:
00144                                         result = bool_to_string(!string_to_bool(first));
00145                                         break;
00146 
00147                                 case SUBSTITUTE_OPCODE:
00148                                         result = substitute(var_get_variable, first);
00149                                         break;
00150 
00151                                 case PROTECT_OPCODE:
00152                                         result = protect(first);
00153                                         break;
00154 
00155                                 case VERBATIM_OPCODE:
00156                                         return (verbatim(first, 0));
00157 
00158                                 case GETENV_OPCODE:
00159                                         result = getenv(first);
00160                                         if (!result)
00161                                                 result = string_Copy("");
00162                                         else
00163                                                 result = string_Copy(result);
00164                                         break;
00165 
00166                                 case UPCASE_OPCODE:
00167                                         return (string_Upcase(first));
00168 
00169                                 case DOWNCASE_OPCODE:
00170                                         return (string_Downcase(first));
00171 
00172                                 case JVAR_OPCODE:
00173                                         result = jVars_get(jVars_stoi(first));
00174                                         if (!result)
00175                                                 result = string_Copy("");
00176                                         else
00177                                                 result = string_Copy(result);
00178                                         break;
00179 
00180                                 case GET_OPCODE:
00181                                         result = read_from_port(first);
00182                                         break;
00183                         }
00184                         free(first);
00185                         break;
00186 
00187                         /*
00188                          * Handle binary operators:
00189                          */
00190                 case PLUS_OPCODE:
00191                 case AND_OPCODE:
00192                 case OR_OPCODE:
00193                 case EQ_OPCODE:
00194                 case NEQ_OPCODE:
00195                 case REGEQ_OPCODE:
00196                 case REGNEQ_OPCODE:
00197                         first = eval_expr(expr->d.nodes.first);
00198                         second = eval_expr(expr->d.nodes.second);
00199 
00200                         switch (opcode) {
00201                                 case PLUS_OPCODE:
00202                                         result = string_Concat(first, second);
00203                                         free(first);
00204                                         free(second);
00205                                         return (result);
00206 
00207                                 case AND_OPCODE:
00208                                         bool_result = string_to_bool(first) && string_to_bool(second);
00209                                         break;
00210 
00211                                 case OR_OPCODE:
00212                                         bool_result = string_to_bool(first) || string_to_bool(second);
00213                                         break;
00214 
00215                                 case EQ_OPCODE:
00216                                         bool_result = string_Eq(first, second);
00217                                         break;
00218 
00219                                 case NEQ_OPCODE:
00220                                         bool_result = string_Neq(first, second);
00221                                         break;
00222 
00223                                 case REGEQ_OPCODE:
00224                                         bool_result = ed_regexp_match_p(first, second);
00225                                         break;
00226 
00227                                 case REGNEQ_OPCODE:
00228                                         bool_result = !ed_regexp_match_p(first, second);
00229                                         break;
00230                         }
00231                         free(first);
00232                         free(second);
00233                         result = bool_to_string(bool_result);
00234                         break;
00235 
00236                         /*
00237                          * Handle text-manipulation operators:
00238                          */
00239                 case LANY_OPCODE:
00240                 case RANY_OPCODE:
00241                 case LBREAK_OPCODE:
00242                 case RBREAK_OPCODE:
00243                 case LSPAN_OPCODE:
00244                 case RSPAN_OPCODE:
00245                 case PARAGRAPH_OPCODE:
00246                         first = eval_expr(expr->d.nodes.first);
00247                         second = eval_expr(expr->d.nodes.second);
00248                         text_ptr = &first;
00249 
00250                         switch (opcode) {
00251                                 case LANY_OPCODE:
00252                                         result = lany(text_ptr, second);
00253                                         break;
00254 
00255                                 case RANY_OPCODE:
00256                                         result = rany(text_ptr, second);
00257                                         break;
00258 
00259                                 case LBREAK_OPCODE:
00260                                         result = lbreak(text_ptr, string_to_character_class(second));
00261                                         break;
00262 
00263                                 case RBREAK_OPCODE:
00264                                         result = rbreak(text_ptr, string_to_character_class(second));
00265                                         break;
00266 
00267                                 case LSPAN_OPCODE:
00268                                         result = lspan(text_ptr, string_to_character_class(second));
00269                                         break;
00270 
00271                                 case RSPAN_OPCODE:
00272                                         result = rspan(text_ptr, string_to_character_class(second));
00273                                         break;
00274 
00275                                 case PARAGRAPH_OPCODE:
00276                                         result = paragraph(text_ptr, atoi(second));
00277                                         break;
00278                         }
00279 
00280                         if (expr->d.nodes.first->opcode == VARREF_OPCODE)
00281                                 var_set_variable(expr->d.nodes.first->d.string_constant, first);
00282                         free(first);
00283                         free(second);
00284                         break;
00285         }
00286 
00287         return (result);
00288 }



Last updated at Tue Dec 18 21:07:42 PST 2007. This site and project hosted by...SourceForge.net Logo

Source Perspective by Fisheye