rendered paste body// =====================================================================================================================================
// allen_cpu_lib_arithmetics.c - Allen version 2.0
// =====================================================================================================================================
//
// This file is part of the Allen Library.
// Last modified: Saturday July 14, 2007.
//
// Copyright (c) 2007, Archville, BSD License.
// A copy can be found here: http://www.opensource.org/licenses/bsd-license.php
// Initally based on Salvatore <antirez> Sanfilippo within Picol 0.1.0
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
// * Neither the name of the Garabatos de licor nor the names of its contributors may
// be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// This software is provided by the copyright holders and contributors
// "as is" and any express or implied warranties, including, but not
// limited to, the implied warranties of merchantability and fitness for
// a particular purpose are disclaimed. in no event shall the copyright owner or
// contributors be liable for any direct, indirect, incidental, special,
// exemplary, or consequential damages (including, but not limited to,
// procurement of substitute goods or services; loss of use, data, or
// profits; or business interruption) however caused and on any theory of
// liability, whether in contract, strict liability, or tort (including
// negligence or otherwise) arising in any way out of the use of this
// software, even if advised of the possibility of such damage.
// =====================================================================================================================================
// Include libraries.
// =====================================================================================================================================
#include <stdio.h> // Standard input/output.
#include <stdlib.h> // Standard C libraries.
#include <string.h> // String libraries.
#include <math.h> // Math libraries.
#include <ctype.h> // Types and conversion libraries.
#include "allen_interpreter.h" // Main interpreter library.
#include "allen_parser.h" // Main parser library.
// =====================================================================================================================================
// Parameters.
// =====================================================================================================================================
#define TLIB_ARITH_BSIZE 1024 // Buffer size.
// =====================================================================================================================================
// Possible errors.
// =====================================================================================================================================
#define TLIB_ARITH_EDIV "arith.*: division parameter is zero." // Error: Division by zero returns indeterminate results.
#define TLIB_ARITH_EMOD "arith.*: modulus parameter is zero." // Error: Modulus by zero returns indeterminate results.
#define TLIB_ARITH_EPAR "arith.*: unexpected or wrong parameters." // Error: Parameters are not satisfied for the command.
#define TLIB_ARITH_EVAL "arith.*: variable does not exist." // Error: Variable does not exist in the interpreter.
#define TLIB_ARITH_EHLP "arith.*: command not found in library." // Error: Command not found in arithmetic library.
// =====================================================================================================================================
// Tokens.
// =====================================================================================================================================
#define TLIB_ARITH_PLS "+" // Addition.
#define TLIB_ARITH_DPLS "++" // Increment.
#define TLIB_ARITH_MIN "-" // Substraction.
#define TLIB_ARITH_DMIN "--" // Decrement.
#define TLIB_ARITH_MUL "*" // Multiplication.
#define TLIB_ARITH_DMUL "**" // Square.
#define TLIB_ARITH_DIV "/" // Division.
#define TLIB_ARITH_DDIV "//" // Division without floating point.
#define TLIB_ARITH_MOD "mod" // Modulus.
#define TLIB_ARITH_POW "pow" // Pow.
#define TLIB_ARITH_VPLS "+:" // Addition in variable.
#define TLIB_ARITH_VDPLS "++:" // Increment in variable.
#define TLIB_ARITH_VMIN "-:" // Substraction in variable.
#define TLIB_ARITH_VDMIN "--:" // Decrement in variable.
#define TLIB_ARITH_VMUL "*:" // Multiplication in variable.
#define TLIB_ARITH_VDMUL "**:" // Square in variable.
#define TLIB_ARITH_VDIV "/:" // Division in variable.
#define TLIB_ARITH_VDDIV "//:" // Division without floating point in variable.
#define TLIB_ARITH_VMOD "mod:" // Modulus in variable.
#define TLIB_ARITH_VPOW "pow:" // Pow in variable.
// =====================================================================================================================================
// Helper Function.
// =====================================================================================================================================
#define TLIB_ARITH_HLP "arith.?" // Helper function.
#define TLIB_ARITH_NIL "nil" // Null value.
// =====================================================================================================================================
// Basic arithmetic operators.
// =====================================================================================================================================
// Allows to perform regular arithmetic operations on value lists
// and return results based on their expressions.
// Index: Example: Result:
// AllenVM_CPU_LIB_ARITH_PLS(); :: + 2 3 4 9.000000
// AllenVM_CPU_LIB_ARITH_DPLS(); :: ++ 2 3.000000
// AllenVM_CPU_LIB_ARITH_MIN(); :: - 2 3 4 -5.000000
// AllenVM_CPU_LIB_ARITH_DMIN(); :: -- 2 1.000000
// AllenVM_CPU_LIB_ARITH_MUL(); :: * 2 3 4 24.000000
// AllenVM_CPU_LIB_ARITH_DMUL(); :: ** 2 4.000000
// AllenVM_CPU_LIB_ARITH_DIV(); :: / 2 3 4 0.166667
// AllenVM_CPU_LIB_ARITH_DDIV(); :: // 2 3 0
// AllenVM_CPU_LIB_ARITH_MOD(); :: mod 10 3 1.000000
// AllenVM_CPU_LIB_ARITH_POW(); :: pow 2 4 16.000000
// Index: Example: Result:
// AllenVM_CPU_LIB_ARITH_VPLS(); :: +: x 10 var.def x [+ $x 10]
// AllenVM_CPU_LIB_ARITH_VDPLS(); :: ++: x var.def x [++ $x]
// AllenVM_CPU_LIB_ARITH_VMIN(); :: -: x 10 var.def x [- $x 10]
// AllenVM_CPU_LIB_ARITH_VDMIN(); :: --: x var.def x [-- $x]
// AllenVM_CPU_LIB_ARITH_VMUL(); :: *: x 10 var.def x [* $x 10]
// AllenVM_CPU_LIB_ARITH_VDMUL(); :: **: x var.def x [** $x]
// AllenVM_CPU_LIB_ARITH_VDIV(); :: /: x 10 var.def x [/ $x 10]
// AllenVM_CPU_LIB_ARITH_VDDIV(); :: //: x 10 var.def x [// $x 10]
// AllenVM_CPU_LIB_ARITH_VMOD(); :: mod: x 10 var.def x [mod $x 10]
// AllenVM_CPU_LIB_ARITH_VPOW(); :: pow: x 10 var.def x [pow $x 10]
// Total: 20.
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_ARITH_PLS();
// Purpose: Addition.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_ARITH_PLS(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc < 2) return AllenVM_CPU_Error(i,TLIB_ARITH_EPAR); // Check parameters.
register int p, op=1; register float c=atof(argv[1]); // Parameters.
for(p=2; p<argc; ++p) { // Loop through parameters.
if(atof(argv[p])==0) { // Check if we want to change operator.
if(!strcmp(TLIB_ARITH_PLS,argv[p])) { op = 1; continue; } // Change operator: Addition.
if(!strcmp(TLIB_ARITH_MIN,argv[p])) { op = 2; continue; } // Change operator: Substraction.
if(!strcmp(TLIB_ARITH_MUL,argv[p])) { op = 3; continue; } // Change operator: Multiplication.
if(!strcmp(TLIB_ARITH_DIV,argv[p])) { op = 4; continue; } // Change operator: Division.
if(!strcmp(TLIB_ARITH_MOD,argv[p])) { op = 5; continue; } // Change operator: Modulus.
if(!strcmp(TLIB_ARITH_POW,argv[p])) { op = 6; continue; } // Change operator: Pow.
}
switch(op) { // Check current operator.
case 1: c += atof(argv[p]); break; // Operate: Addition.
case 2: c -= atof(argv[p]); break; // Operate: Substraction.
case 3: c *= atof(argv[p]); break; // Operate: Multiplication.
case 4: c /= atof(argv[p]); break; // Operate: Division.
case 5: c = (int) c % atoi(argv[p]); break; // Operate: Modulus.
case 6: c = pow(c,atof(argv[p])); break; // Operate: Pow.
}}
char buf[TLIB_ARITH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_ARITH_BSIZE,"%f",c); // Copy result to buffer as float.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
};
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_ARITH_DPLS();
// Purpose: Increment.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_ARITH_DPLS(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc != 2) return AllenVM_CPU_Error(i,TLIB_ARITH_EPAR); // Check parameters.
register float c=atof(argv[1])+1; // Operate.
char buf[TLIB_ARITH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_ARITH_BSIZE,"%f",c); // Copy result to buffer as float.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_ARITH_MIN();
// Purpose: Substraction.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_ARITH_MIN(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc < 2) return AllenVM_CPU_Error(i,TLIB_ARITH_EPAR); // Check parameters.
register int p, op=2; register float c=atof(argv[1]); // Parameters.
for(p=2; p<argc; ++p) { // Loop through parameters.
if(atof(argv[p])==0) { // Check if we want to change operator.
if(!strcmp(TLIB_ARITH_PLS,argv[p])) { op = 1; continue; } // Change operator: Addition.
if(!strcmp(TLIB_ARITH_MIN,argv[p])) { op = 2; continue; } // Change operator: Substraction.
if(!strcmp(TLIB_ARITH_MUL,argv[p])) { op = 3; continue; } // Change operator: Multiplication.
if(!strcmp(TLIB_ARITH_DIV,argv[p])) { op = 4; continue; } // Change operator: Division.
if(!strcmp(TLIB_ARITH_MOD,argv[p])) { op = 5; continue; } // Change operator: Modulus.
if(!strcmp(TLIB_ARITH_POW,argv[p])) { op = 6; continue; } // Change operator: Pow.
}
switch(op) { // Check current operator.
case 1: c += atof(argv[p]); break; // Operate: Addition.
case 2: c -= atof(argv[p]); break; // Operate: Substraction.
case 3: c *= atof(argv[p]); break; // Operate: Multiplication.
case 4: c /= atof(argv[p]); break; // Operate: Division.
case 5: c = (int) c % atoi(argv[p]); break; // Operate: Modulus.
case 6: c = pow(c,atof(argv[p])); break; // Operate: Pow.
}}
char buf[TLIB_ARITH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_ARITH_BSIZE,"%f",c); // Copy result to buffer as float.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_ARITH_DMIN();
// Purpose: Decrement.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_ARITH_DMIN(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc != 2) return AllenVM_CPU_Error(i,TLIB_ARITH_EPAR); // Check parameters.
register float c=atof(argv[1])-1; // Operate.
char buf[TLIB_ARITH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_ARITH_BSIZE,"%f",c); // Copy result to buffer as float.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_ARITH_MUL();
// Purpose: Multiplication.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_ARITH_MUL(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc < 2) return AllenVM_CPU_Error(i,TLIB_ARITH_EPAR); // Check parameters.
register int p, op=3; register float c=atof(argv[1]); // Parameters.
for(p=2; p<argc; ++p) { // Loop through parameters.
if(atof(argv[p])==0) { // Check if we want to change operator.
if(!strcmp(TLIB_ARITH_PLS,argv[p])) { op = 1; continue; } // Change operator: Addition.
if(!strcmp(TLIB_ARITH_MIN,argv[p])) { op = 2; continue; } // Change operator: Substraction.
if(!strcmp(TLIB_ARITH_MUL,argv[p])) { op = 3; continue; } // Change operator: Multiplication.
if(!strcmp(TLIB_ARITH_DIV,argv[p])) { op = 4; continue; } // Change operator: Division.
if(!strcmp(TLIB_ARITH_MOD,argv[p])) { op = 5; continue; } // Change operator: Modulus.
if(!strcmp(TLIB_ARITH_POW,argv[p])) { op = 6; continue; } // Change operator: Pow.
}
switch(op) { // Check current operator.
case 1: c += atof(argv[p]); break; // Operate: Addition.
case 2: c -= atof(argv[p]); break; // Operate: Substraction.
case 3: c *= atof(argv[p]); break; // Operate: Multiplication.
case 4: c /= atof(argv[p]); break; // Operate: Division.
case 5: c = (int) c % atoi(argv[p]); break; // Operate: Modulus.
case 6: c = pow(c,atof(argv[p])); break; // Operate: Pow.
}}
char buf[TLIB_ARITH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_ARITH_BSIZE,"%f",c); // Copy result to buffer as float.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_ARITH_DMUL();
// Purpose: Square.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_ARITH_DMUL(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc != 2) return AllenVM_CPU_Error(i,TLIB_ARITH_EPAR); // Check parameters.
register float c=atof(argv[1])*atof(argv[1]); // Operate.
char buf[TLIB_ARITH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_ARITH_BSIZE,"%f",c); // Copy result to buffer as float.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_ARITH_DIV();
// Purpose: Division.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_ARITH_DIV(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc < 2) return AllenVM_CPU_Error(i,TLIB_ARITH_EPAR); // Check parameters.
register int p, op=4; register float c=atof(argv[1]); // Parameters.
for(p=2; p<argc; ++p) { // Loop through parameters.
if(atof(argv[p])==0) { // Check if we want to change operator.
if(!strcmp(TLIB_ARITH_PLS,argv[p])) { op = 1; continue; } // Change operator: Addition.
if(!strcmp(TLIB_ARITH_MIN,argv[p])) { op = 2; continue; } // Change operator: Substraction.
if(!strcmp(TLIB_ARITH_MUL,argv[p])) { op = 3; continue; } // Change operator: Multiplication.
if(!strcmp(TLIB_ARITH_DIV,argv[p])) { op = 4; continue; } // Change operator: Division.
if(!strcmp(TLIB_ARITH_MOD,argv[p])) { op = 5; continue; } // Change operator: Modulus.
if(!strcmp(TLIB_ARITH_POW,argv[p])) { op = 6; continue; } // Change operator: Pow.
}
switch(op) { // Check current operator.
case 1: c += atof(argv[p]); break; // Operate: Addition.
case 2: c -= atof(argv[p]); break; // Operate: Substraction.
case 3: c *= atof(argv[p]); break; // Operate: Multiplication.
case 4: c /= atof(argv[p]); break; // Operate: Division.
case 5: c = (int) c % atoi(argv[p]); break; // Operate: Modulus.
case 6: c = pow(c,atof(argv[p])); break; // Operate: Pow.
}}
char buf[TLIB_ARITH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_ARITH_BSIZE,"%f",c); // Copy result to buffer as float.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_ARITH_DDIV();
// Purpose: Division without floating point.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_ARITH_DDIV(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc < 2) return AllenVM_CPU_Error(i,TLIB_ARITH_EPAR); // Check parameters.
register int p; register float c=atof(argv[1]); // Parameters.
for(p=2; p<argc; ++p) { // Loop through parameters.
if(atof(argv[p]) == 0) return AllenVM_CPU_Error(i,TLIB_ARITH_EDIV); // Check for errors.
c /= atof(argv[p]); } // Division.
char buf[TLIB_ARITH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_ARITH_BSIZE,"%d",(int) c); // Copy result to buffer as integer.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_ARITH_MOD();
// Purpose: Modulus.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_ARITH_MOD(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc < 2) return AllenVM_CPU_Error(i,TLIB_ARITH_EPAR); // Check parameters.
register int p, op=5; register float c=atof(argv[1]); // Parameters.
for(p=2; p<argc; ++p) { // Loop through parameters.
if(atof(argv[p])==0) { // Check if we want to change operator.
if(!strcmp(TLIB_ARITH_PLS,argv[p])) { op = 1; continue; } // Change operator: Addition.
if(!strcmp(TLIB_ARITH_MIN,argv[p])) { op = 2; continue; } // Change operator: Substraction.
if(!strcmp(TLIB_ARITH_MUL,argv[p])) { op = 3; continue; } // Change operator: Multiplication.
if(!strcmp(TLIB_ARITH_DIV,argv[p])) { op = 4; continue; } // Change operator: Division.
if(!strcmp(TLIB_ARITH_MOD,argv[p])) { op = 5; continue; } // Change operator: Modulus.
if(!strcmp(TLIB_ARITH_POW,argv[p])) { op = 6; continue; } // Change operator: Pow.
}
switch(op) { // Check current operator.
case 1: c += atof(argv[p]); break; // Operate: Addition.
case 2: c -= atof(argv[p]); break; // Operate: Substraction.
case 3: c *= atof(argv[p]); break; // Operate: Multiplication.
case 4: c /= atof(argv[p]); break; // Operate: Division.
case 5: c = (int) c % atoi(argv[p]); break; // Operate: Modulus.
case 6: c = pow(c,atof(argv[p])); break; // Operate: Pow.
}}
char buf[TLIB_ARITH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_ARITH_BSIZE,"%f",c); // Copy result to buffer as float.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_ARITH_POW();
// Purpose: Pow.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_ARITH_POW(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc < 2) return AllenVM_CPU_Error(i,TLIB_ARITH_EPAR); // Check parameters.
register int p, op=6; register float c=atof(argv[1]); // Parameters.
for(p=2; p<argc; ++p) { // Loop through parameters.
if(atof(argv[p])==0) { // Check if we want to change operator.
if(!strcmp(TLIB_ARITH_PLS,argv[p])) { op = 1; continue; } // Change operator: Addition.
if(!strcmp(TLIB_ARITH_MIN,argv[p])) { op = 2; continue; } // Change operator: Substraction.
if(!strcmp(TLIB_ARITH_MUL,argv[p])) { op = 3; continue; } // Change operator: Multiplication.
if(!strcmp(TLIB_ARITH_DIV,argv[p])) { op = 4; continue; } // Change operator: Division.
if(!strcmp(TLIB_ARITH_MOD,argv[p])) { op = 5; continue; } // Change operator: Modulus.
if(!strcmp(TLIB_ARITH_POW,argv[p])) { op = 6; continue; } // Change operator: Pow.
}
switch(op) { // Check current operator.
case 1: c += atof(argv[p]); break; // Operate: Addition.
case 2: c -= atof(argv[p]); break; // Operate: Substraction.
case 3: c *= atof(argv[p]); break; // Operate: Multiplication.
case 4: c /= atof(argv[p]); break; // Operate: Division.
case 5: c = (int) c % atoi(argv[p]); break; // Operate: Modulus.
case 6: c = pow(c,atof(argv[p])); break; // Operate: Pow.
}}
char buf[TLIB_ARITH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_ARITH_BSIZE,"%f",c); // Copy result to buffer as float.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_ARITH_VPLS();
// Purpose: Addition in variable.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_ARITH_VPLS(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc < 3) return AllenVM_CPU_Error(i,TLIB_ARITH_EPAR); // Check parameters.
struct AllenVar *v; // Variable struct.
if((v = (void*) AllenVM_InterpGetVar(i,argv[1])) == NULL) // Check variable for existence.
return AllenVM_CPU_Error(i,TLIB_ARITH_EVAL); // Does not exist, error.
register int p, op=1; register float c=atof(v->c_val); // Parameters.
for(p=2; p<argc; ++p) { // Loop through parameters.
if(atof(argv[p])==0) { // Check if we want to change operator.
if(!strcmp(TLIB_ARITH_PLS,argv[p])) { op = 1; continue; } // Change operator: Addition.
if(!strcmp(TLIB_ARITH_MIN,argv[p])) { op = 2; continue; } // Change operator: Substraction.
if(!strcmp(TLIB_ARITH_MUL,argv[p])) { op = 3; continue; } // Change operator: Multiplication.
if(!strcmp(TLIB_ARITH_DIV,argv[p])) { op = 4; continue; } // Change operator: Division.
if(!strcmp(TLIB_ARITH_MOD,argv[p])) { op = 5; continue; } // Change operator: Modulus.
if(!strcmp(TLIB_ARITH_POW,argv[p])) { op = 6; continue; } // Change operator: Pow.
}
switch(op) { // Check current operator.
case 1: c += atof(argv[p]); break; // Operate: Addition.
case 2: c -= atof(argv[p]); break; // Operate: Substraction.
case 3: c *= atof(argv[p]); break; // Operate: Multiplication.
case 4: c /= atof(argv[p]); break; // Operate: Division.
case 5: c = (int) c % atoi(argv[p]); break; // Operate: Modulus.
case 6: c = pow(c,atof(argv[p])); break; // Operate: Pow.
}}
char buf[TLIB_ARITH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_ARITH_BSIZE,"%f",c); // Copy result to buffer as float.
if((p=AllenVM_InterpSetVar(i,argv[1],buf,0)) != Allen_VM_OK) return p; // Set the new variable value.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_ARITH_VDPLS();
// Purpose: Increment in variable.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_ARITH_VDPLS(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc != 2) return AllenVM_CPU_Error(i,TLIB_ARITH_EPAR); // Check parameters.
struct AllenVar *v; // Variable struct.
if((v = (void*) AllenVM_InterpGetVar(i,argv[1])) == NULL) // Check variable for existence.
return AllenVM_CPU_Error(i,TLIB_ARITH_EVAL); // Does not exist, error.
register float c=atof(v->c_val)+1; // Operate.
register int p; // Variable assignement result.
char buf[TLIB_ARITH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_ARITH_BSIZE,"%f",c); // Copy result to buffer as float.
if((p=AllenVM_InterpSetVar(i,argv[1],buf,0)) != Allen_VM_OK) return p; // Set the new variable value.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_ARITH_VMIN();
// Purpose: Substraction in variable.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_ARITH_VMIN(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc < 3) return AllenVM_CPU_Error(i,TLIB_ARITH_EPAR); // Check parameters.
struct AllenVar *v; // Variable struct.
if((v = (void*) AllenVM_InterpGetVar(i,argv[1])) == NULL) // Check variable for existence.
return AllenVM_CPU_Error(i,TLIB_ARITH_EVAL); // Does not exist, error.
register int p, op=2; register float c=atof(v->c_val); // Parameters.
for(p=2; p<argc; ++p) { // Loop through parameters.
if(atof(argv[p])==0) { // Check if we want to change operator.
if(!strcmp(TLIB_ARITH_PLS,argv[p])) { op = 1; continue; } // Change operator: Addition.
if(!strcmp(TLIB_ARITH_MIN,argv[p])) { op = 2; continue; } // Change operator: Substraction.
if(!strcmp(TLIB_ARITH_MUL,argv[p])) { op = 3; continue; } // Change operator: Multiplication.
if(!strcmp(TLIB_ARITH_DIV,argv[p])) { op = 4; continue; } // Change operator: Division.
if(!strcmp(TLIB_ARITH_MOD,argv[p])) { op = 5; continue; } // Change operator: Modulus.
if(!strcmp(TLIB_ARITH_POW,argv[p])) { op = 6; continue; } // Change operator: Pow.
}
switch(op) { // Check current operator.
case 1: c += atof(argv[p]); break; // Operate: Addition.
case 2: c -= atof(argv[p]); break; // Operate: Substraction.
case 3: c *= atof(argv[p]); break; // Operate: Multiplication.
case 4: c /= atof(argv[p]); break; // Operate: Division.
case 5: c = (int) c % atoi(argv[p]); break; // Operate: Modulus.
case 6: c = pow(c,atof(argv[p])); break; // Operate: Pow.
}}
char buf[TLIB_ARITH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_ARITH_BSIZE,"%f",c); // Copy result to buffer as float.
if((p=AllenVM_InterpSetVar(i,argv[1],buf,0)) != Allen_VM_OK) return p; // Set the new variable value.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_ARITH_VDMIN();
// Purpose: Decrement in variable.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_ARITH_VDMIN(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc != 2) return AllenVM_CPU_Error(i,TLIB_ARITH_EPAR); // Check parameters.
struct AllenVar *v; // Variable struct.
if((v = (void*) AllenVM_InterpGetVar(i,argv[1])) == NULL) // Check variable for existence.
return AllenVM_CPU_Error(i,TLIB_ARITH_EVAL); // Does not exist, error.
register float c=atof(v->c_val)-1; // Operate.
register int p; // Variable assignement result.
char buf[TLIB_ARITH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_ARITH_BSIZE,"%f",c); // Copy result to buffer as float.
if((p=AllenVM_InterpSetVar(i,argv[1],buf,0)) != Allen_VM_OK) return p; // Set the new variable value.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_ARITH_VMUL();
// Purpose: Multiplication in variable.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_ARITH_VMUL(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc < 3) return AllenVM_CPU_Error(i,TLIB_ARITH_EPAR); // Check parameters.
struct AllenVar *v; // Variable struct.
if((v = (void*) AllenVM_InterpGetVar(i,argv[1])) == NULL) // Check variable for existence.
return AllenVM_CPU_Error(i,TLIB_ARITH_EVAL); // Does not exist, error.
register int p, op=3; register float c=atof(v->c_val); // Parameters.
for(p=2; p<argc; ++p) { // Loop through parameters.
if(atof(argv[p])==0) { // Check if we want to change operator.
if(!strcmp(TLIB_ARITH_PLS,argv[p])) { op = 1; continue; } // Change operator: Addition.
if(!strcmp(TLIB_ARITH_MIN,argv[p])) { op = 2; continue; } // Change operator: Substraction.
if(!strcmp(TLIB_ARITH_MUL,argv[p])) { op = 3; continue; } // Change operator: Multiplication.
if(!strcmp(TLIB_ARITH_DIV,argv[p])) { op = 4; continue; } // Change operator: Division.
if(!strcmp(TLIB_ARITH_MOD,argv[p])) { op = 5; continue; } // Change operator: Modulus.
if(!strcmp(TLIB_ARITH_POW,argv[p])) { op = 6; continue; } // Change operator: Pow.
}
switch(op) { // Check current operator.
case 1: c += atof(argv[p]); break; // Operate: Addition.
case 2: c -= atof(argv[p]); break; // Operate: Substraction.
case 3: c *= atof(argv[p]); break; // Operate: Multiplication.
case 4: c /= atof(argv[p]); break; // Operate: Division.
case 5: c = (int) c % atoi(argv[p]); break; // Operate: Modulus.
case 6: c = pow(c,atof(argv[p])); break; // Operate: Pow.
}}
char buf[TLIB_ARITH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_ARITH_BSIZE,"%f",c); // Copy result to buffer as float.
if((p=AllenVM_InterpSetVar(i,argv[1],buf,0)) != Allen_VM_OK) return p; // Set the new variable value.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_ARITH_VDMUL();
// Purpose: Square in variable.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_ARITH_VDMUL(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc != 2) return AllenVM_CPU_Error(i,TLIB_ARITH_EPAR); // Check parameters.
struct AllenVar *v; // Variable struct.
if((v = (void*) AllenVM_InterpGetVar(i,argv[1])) == NULL) // Check variable for existence.
return AllenVM_CPU_Error(i,TLIB_ARITH_EVAL); // Does not exist, error.
register float c=atof(v->c_val) * atof(v->c_val); // Operate.
register int p; // Variable assignement result.
char buf[TLIB_ARITH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_ARITH_BSIZE,"%f",c); // Copy result to buffer as float.
if((p=AllenVM_InterpSetVar(i,argv[1],buf,0)) != Allen_VM_OK) return p; // Set the new variable value.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_ARITH_VDIV();
// Purpose: Division in variable.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_ARITH_VDIV(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc < 3) return AllenVM_CPU_Error(i,TLIB_ARITH_EPAR); // Check parameters.
struct AllenVar *v; // Variable struct.
if((v = (void*) AllenVM_InterpGetVar(i,argv[1])) == NULL) // Check variable for existence.
return AllenVM_CPU_Error(i,TLIB_ARITH_EVAL); // Does not exist, error.
register int p, op=4; register float c=atof(v->c_val); // Parameters.
for(p=2; p<argc; ++p) { // Loop through parameters.
if(atof(argv[p])==0) { // Check if we want to change operator.
if(!strcmp(TLIB_ARITH_PLS,argv[p])) { op = 1; continue; } // Change operator: Addition.
if(!strcmp(TLIB_ARITH_MIN,argv[p])) { op = 2; continue; } // Change operator: Substraction.
if(!strcmp(TLIB_ARITH_MUL,argv[p])) { op = 3; continue; } // Change operator: Multiplication.
if(!strcmp(TLIB_ARITH_DIV,argv[p])) { op = 4; continue; } // Change operator: Division.
if(!strcmp(TLIB_ARITH_MOD,argv[p])) { op = 5; continue; } // Change operator: Modulus.
if(!strcmp(TLIB_ARITH_POW,argv[p])) { op = 6; continue; } // Change operator: Pow.
}
switch(op) { // Check current operator.
case 1: c += atof(argv[p]); break; // Operate: Addition.
case 2: c -= atof(argv[p]); break; // Operate: Substraction.
case 3: c *= atof(argv[p]); break; // Operate: Multiplication.
case 4: c /= atof(argv[p]); break; // Operate: Division.
case 5: c = (int) c % atoi(argv[p]); break; // Operate: Modulus.
case 6: c = pow(c,atof(argv[p])); break; // Operate: Pow.
}}
char buf[TLIB_ARITH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_ARITH_BSIZE,"%f",c); // Copy result to buffer as float.
if((p=AllenVM_InterpSetVar(i,argv[1],buf,0)) != Allen_VM_OK) return p; // Set the new variable value.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_ARITH_VDDIV();
// Purpose: Division without floating point in variable.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_ARITH_VDDIV(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc < 3) return AllenVM_CPU_Error(i,TLIB_ARITH_EPAR); // Check parameters.
struct AllenVar *v; // Variable struct.
if((v = (void*) AllenVM_InterpGetVar(i,argv[1])) == NULL) // Check variable for existence.
return AllenVM_CPU_Error(i,TLIB_ARITH_EVAL); // Does not exist, error.
register int p; register float c=atof(v->c_val); // Parameters.
for(p=2; p<argc; ++p) c/=atof(argv[p]); // Operate.
char buf[TLIB_ARITH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_ARITH_BSIZE,"%d",(int) c); // Copy result to buffer as integer.
if((p=AllenVM_InterpSetVar(i,argv[1],buf,0)) != Allen_VM_OK) return p; // Set the new variable value.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_ARITH_VMOD();
// Purpose: Modulus in variable.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_ARITH_VMOD(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc < 3) return AllenVM_CPU_Error(i,TLIB_ARITH_EPAR); // Check parameters.
struct AllenVar *v; // Variable struct.
if((v = (void*) AllenVM_InterpGetVar(i,argv[1])) == NULL) // Check variable for existence.
return AllenVM_CPU_Error(i,TLIB_ARITH_EVAL); // Does not exist, error.
register int p, op=5; register float c=atof(v->c_val); // Parameters.
for(p=2; p<argc; ++p) { // Loop through parameters.
if(atof(argv[p])==0) { // Check if we want to change operator.
if(!strcmp(TLIB_ARITH_PLS,argv[p])) { op = 1; continue; } // Change operator: Addition.
if(!strcmp(TLIB_ARITH_MIN,argv[p])) { op = 2; continue; } // Change operator: Substraction.
if(!strcmp(TLIB_ARITH_MUL,argv[p])) { op = 3; continue; } // Change operator: Multiplication.
if(!strcmp(TLIB_ARITH_DIV,argv[p])) { op = 4; continue; } // Change operator: Division.
if(!strcmp(TLIB_ARITH_MOD,argv[p])) { op = 5; continue; } // Change operator: Modulus.
if(!strcmp(TLIB_ARITH_POW,argv[p])) { op = 6; continue; } // Change operator: Pow.
}
switch(op) { // Check current operator.
case 1: c += atof(argv[p]); break; // Operate: Addition.
case 2: c -= atof(argv[p]); break; // Operate: Substraction.
case 3: c *= atof(argv[p]); break; // Operate: Multiplication.
case 4: c /= atof(argv[p]); break; // Operate: Division.
case 5: c = (int) c % atoi(argv[p]); break; // Operate: Modulus.
case 6: c = pow(c,atof(argv[p])); break; // Operate: Pow.
}}
char buf[TLIB_ARITH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_ARITH_BSIZE,"%f",c); // Copy result to buffer as float.
if((p=AllenVM_InterpSetVar(i,argv[1],buf,0)) != Allen_VM_OK) return p; // Set the new variable value.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_ARITH_VPOW();
// Purpose: Pow in variable.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_ARITH_VPOW(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc < 3) return AllenVM_CPU_Error(i,TLIB_ARITH_EPAR); // Check parameters.
struct AllenVar *v; // Variable struct.
if((v = (void*) AllenVM_InterpGetVar(i,argv[1])) == NULL) // Check variable for existence.
return AllenVM_CPU_Error(i,TLIB_ARITH_EVAL); // Does not exist, error.
register int p, op=6; register float c=atof(v->c_val); // Parameters.
for(p=2; p<argc; ++p) { // Loop through parameters.
if(atof(argv[p])==0) { // Check if we want to change operator.
if(!strcmp(TLIB_ARITH_PLS,argv[p])) { op = 1; continue; } // Change operator: Addition.
if(!strcmp(TLIB_ARITH_MIN,argv[p])) { op = 2; continue; } // Change operator: Substraction.
if(!strcmp(TLIB_ARITH_MUL,argv[p])) { op = 3; continue; } // Change operator: Multiplication.
if(!strcmp(TLIB_ARITH_DIV,argv[p])) { op = 4; continue; } // Change operator: Division.
if(!strcmp(TLIB_ARITH_MOD,argv[p])) { op = 5; continue; } // Change operator: Modulus.
if(!strcmp(TLIB_ARITH_POW,argv[p])) { op = 6; continue; } // Change operator: Pow.
}
switch(op) { // Check current operator.
case 1: c += atof(argv[p]); break; // Operate: Addition.
case 2: c -= atof(argv[p]); break; // Operate: Substraction.
case 3: c *= atof(argv[p]); break; // Operate: Multiplication.
case 4: c /= atof(argv[p]); break; // Operate: Division.
case 5: c = (int) c % atoi(argv[p]); break; // Operate: Modulus.
case 6: c = pow(c,atof(argv[p])); break; // Operate: Pow.
}}
char buf[TLIB_ARITH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_ARITH_BSIZE,"%f",c); // Copy result to buffer as float.
if((p=AllenVM_InterpSetVar(i,argv[1],buf,0)) != Allen_VM_OK) return p; // Set the new variable value.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_ARITH_HLP();
// Purpose: Adds help facilities
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_ARITH_HLP(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc != 2) return AllenVM_CPU_Error(i,TLIB_ARITH_EPAR); // Check parameters.
if(!strcmp(TLIB_ARITH_PLS,argv[1])) { // Compare parameters.
puts("Description: Adds a list of numbers."); // Description.
puts("Returns: Float number from expression result. "); // Returns.
puts("Sample: + 2 2 3 4 => 11.000000"); // Sample function.
puts("Parameters: min: 1 max: ANY"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_ARITH_PLS); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_ARITH_DPLS,argv[1])) { // Compare parameters.
puts("Description: Increments it's parameter by one."); // Description.
puts("Returns: Float number from expression result. "); // Returns.
puts("Sample: ++ 5 => 6.000000"); // Sample function.
puts("Parameters: min: 1 max: 1"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_ARITH_DPLS); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_ARITH_MIN,argv[1])) { // Compare parameters.
puts("Description: Substracts a list of numbers."); // Description.
puts("Returns: Float number from expression result. "); // Returns.
puts("Sample: - 5 10 21 => - 26.000000"); // Sample function.
puts("Parameters: min: 1 max: ANY"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_ARITH_MIN); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_ARITH_DMIN,argv[1])) { // Compare parameters.
puts("Description: Decrements it's parameter by one."); // Description.
puts("Returns: Float number from expression result. "); // Returns.
puts("Sample: -- 5 => 4.000000"); // Sample function.
puts("Parameters: min: 1 max: 1"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_ARITH_DMIN); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_ARITH_MUL,argv[1])) { // Compare parameters.
puts("Description: Multiplies a list of numbers."); // Description.
puts("Returns: Float number from expression result. "); // Returns.
puts("Sample: * 5 4 2 => 40.000000"); // Sample function.
puts("Parameters: min: 1 max: ANY"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_ARITH_MUL); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_ARITH_DMUL,argv[1])) { // Compare parameters.
puts("Description: Calculates the square of a number."); // Description.
puts("Returns: Float number from expression result. "); // Returns.
puts("Sample: ** 10 => 100.000000"); // Sample function.
puts("Parameters: min: 1 max: 1"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_ARITH_DMUL); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_ARITH_DIV,argv[1])) { // Compare parameters.
puts("Description: Divides a list of numbers."); // Description.
puts("Returns: Float number from expression result. "); // Returns.
puts("Sample: / 5 2 1 => 2.500000"); // Sample function.
puts("Parameters: min: 1 max: ANY"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_ARITH_DIV); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_ARITH_DDIV,argv[1])) { // Compare parameters.
puts("Description: Divides a list of numbers."); // Description.
puts("Returns: Integer number from expression result. "); // Returns.
puts("Sample: // 5 2 1 => 2.000000"); // Sample function.
puts("Parameters: min: 1 max: ANY"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_ARITH_DDIV); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_ARITH_MOD,argv[1])) { // Compare parameters.
puts("Description: Calculates modulus of a division."); // Description.
puts("Returns: Float number from expression result. "); // Returns.
puts("Sample: mod 10 3 => 1.000000"); // Sample function.
puts("Parameters: min: 1 max: ANY"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_ARITH_MOD); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_ARITH_POW,argv[1])) { // Compare parameters.
puts("Description: Calculates the pow of a list of numbers."); // Description.
puts("Returns: Float number from expression result. "); // Returns.
puts("Sample: pow 2 3 => 8.000000"); // Sample function.
puts("Parameters: min: 1 max: ANY"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_ARITH_POW); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_ARITH_VPLS,argv[1])) { // Compare parameters.
puts("Description: Adds a list of numbers to a variable."); // Description.
puts("Returns: Float number from expression result. "); // Returns.
puts("Sample: +: x 10 => var.def x [+ $x 10]"); // Sample function.
puts("Parameters: min: 2 max: ANY"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_ARITH_VPLS); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_ARITH_VDPLS,argv[1])) { // Compare parameters.
puts("Description: Increments a variable."); // Description.
puts("Returns: Float number from expression result. "); // Returns.
puts("Sample: ++: x => var.def x [++ $x];"); // Sample function.
puts("Parameters: min: 1 max: 1"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_ARITH_VDPLS); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_ARITH_VMIN,argv[1])) { // Compare parameters.
puts("Description: Substracts a list of numbers from a variable."); // Description.
puts("Returns: Float number from expression result. "); // Returns.
puts("Sample: -: x 10 => var.def x [- $x 10]"); // Sample function.
puts("Parameters: min: 2 max: ANY"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_ARITH_VMIN); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_ARITH_VDMIN,argv[1])) { // Compare parameters.
puts("Description: Decrements a variable."); // Description.
puts("Returns: Float number from expression result. "); // Returns.
puts("Sample: --: x => var.def x [-- $x]"); // Sample function.
puts("Parameters: min: 1 max: 1"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_ARITH_VDMIN); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_ARITH_VMUL,argv[1])) { // Compare parameters.
puts("Description: Multiplies a variable by a list of numbers."); // Description.
puts("Returns: Float number from expression result. "); // Returns.
puts("Sample: *: x 5 => var.def x [* $x 5]"); // Sample function.
puts("Parameters: min: 2 max: ANY"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_ARITH_VMUL); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_ARITH_VDMUL,argv[1])) { // Compare parameters.
puts("Description: Multiplies a variable by self."); // Description.
puts("Returns: Float number from expression result. "); // Returns.
puts("Sample: **: x => var.def x [** $x]"); // Sample function.
puts("Parameters: min: 1 max: 1"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_ARITH_VDMUL); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_ARITH_VDIV,argv[1])) { // Compare parameters.
puts("Description: Divides a variable by a list of numbers."); // Description.
puts("Returns: Float number from expression result. "); // Returns.
puts("Sample: /: x 10 => var.def x [/ $x 10]"); // Sample function.
puts("Parameters: min: 2 max: ANY"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_ARITH_VDIV); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_ARITH_VDDIV,argv[1])) { // Compare parameters.
puts("Description: Divides a variable by a list of numbers."); // Description.
puts("Returns: Integer number from expression result. "); // Returns.
puts("Sample: //: x 2 => var.def x [// $x 2]"); // Sample function.
puts("Parameters: min: 1 max: ANY"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_ARITH_VDDIV); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_ARITH_VMOD,argv[1])) { // Compare parameters.
puts("Description: Calculates modulus of a division in a variable."); // Description.
puts("Returns: Float number from expression result. "); // Returns.
puts("Sample: mod: x 3 => var.def x [mod $x 3]"); // Sample function.
puts("Parameters: min: 2 max: ANY"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_ARITH_VMOD); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_ARITH_VPOW,argv[1])) { // Compare parameters.
puts("Description: Calculates the pow of a variable by a list of numbers."); // Description.
puts("Returns: Float number from expression result. "); // Returns.
puts("Sample: pow: x 3 => var.def x [pow $x 3]"); // Sample function.
puts("Parameters: min: 2 max: ANY"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_ARITH_VPOW); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
AllenVM_InterpSetResult(i,TLIB_ARITH_NIL); // Set interpreter result.
return AllenVM_CPU_Error(i,TLIB_ARITH_EHLP); // Command not found.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_ARITH_ADD();
// Purpose: Add instructions to the CPU.
// Returns: Void (nothing).
// -------------------------------------------------------------------------------------------------------------------------------------
void AllenVM_CPU_LIB_ARITH_ADD(struct AllenInterp *i) {
AllenVM_InterpSetCommand(i,TLIB_ARITH_PLS, AllenVM_CPU_LIB_ARITH_PLS, NULL); // Addition.
AllenVM_InterpSetCommand(i,TLIB_ARITH_DPLS, AllenVM_CPU_LIB_ARITH_DPLS, NULL); // Increment.
AllenVM_InterpSetCommand(i,TLIB_ARITH_MIN, AllenVM_CPU_LIB_ARITH_MIN, NULL); // Substraction.
AllenVM_InterpSetCommand(i,TLIB_ARITH_DMIN, AllenVM_CPU_LIB_ARITH_DMIN, NULL); // Decrement.
AllenVM_InterpSetCommand(i,TLIB_ARITH_MUL, AllenVM_CPU_LIB_ARITH_MUL, NULL); // Multiplication.
AllenVM_InterpSetCommand(i,TLIB_ARITH_DMUL, AllenVM_CPU_LIB_ARITH_DMUL, NULL); // Square.
AllenVM_InterpSetCommand(i,TLIB_ARITH_DIV, AllenVM_CPU_LIB_ARITH_DIV, NULL); // Division.
AllenVM_InterpSetCommand(i,TLIB_ARITH_DDIV, AllenVM_CPU_LIB_ARITH_DDIV, NULL); // Division without floating point.
AllenVM_InterpSetCommand(i,TLIB_ARITH_MOD, AllenVM_CPU_LIB_ARITH_MOD, NULL); // Modulus.
AllenVM_InterpSetCommand(i,TLIB_ARITH_POW, AllenVM_CPU_LIB_ARITH_POW, NULL); // Pow.
AllenVM_InterpSetCommand(i,TLIB_ARITH_VPLS, AllenVM_CPU_LIB_ARITH_VPLS, NULL); // Addition in variable.
AllenVM_InterpSetCommand(i,TLIB_ARITH_VDPLS, AllenVM_CPU_LIB_ARITH_VDPLS, NULL); // Increment in variable.
AllenVM_InterpSetCommand(i,TLIB_ARITH_VMIN, AllenVM_CPU_LIB_ARITH_VMIN, NULL); // Substraction in variable.
AllenVM_InterpSetCommand(i,TLIB_ARITH_VDMIN, AllenVM_CPU_LIB_ARITH_VDMIN, NULL); // Decrement in variable.
AllenVM_InterpSetCommand(i,TLIB_ARITH_VMUL, AllenVM_CPU_LIB_ARITH_VMUL, NULL); // Multiplication in variable.
AllenVM_InterpSetCommand(i,TLIB_ARITH_VDMUL, AllenVM_CPU_LIB_ARITH_VDMUL, NULL); // Square in variable.
AllenVM_InterpSetCommand(i,TLIB_ARITH_VDIV, AllenVM_CPU_LIB_ARITH_VDIV, NULL); // Division in variable
AllenVM_InterpSetCommand(i,TLIB_ARITH_VDDIV, AllenVM_CPU_LIB_ARITH_VDDIV, NULL); // Division without fp in variable.
AllenVM_InterpSetCommand(i,TLIB_ARITH_VMOD, AllenVM_CPU_LIB_ARITH_VMOD, NULL); // Modulus in variable.
AllenVM_InterpSetCommand(i,TLIB_ARITH_VPOW, AllenVM_CPU_LIB_ARITH_VPOW, NULL); // Pow in variable.
AllenVM_InterpSetCommand(i,TLIB_ARITH_HLP, AllenVM_CPU_LIB_ARITH_HLP, NULL); // Helper function.
}
// =====================================================================================================================================
// EOF
// =====================================================================================================================================
// Compiler parameters: Gcc -O2 -lm
// Recommended editor: Scite/Gedit/Vim.