예제 #1
0
le * evaluateBranch( lithp_burrito *lb, le * trybranch)
{
    le * keyword;
    int tryit = 0;
    if (!trybranch) return( NULL );

    if (trybranch->branch) {
        keyword = evaluateBranch(lb, trybranch->branch);
    } else
        keyword = leNew( trybranch->data );

    if (!keyword->data) {
        leWipe( keyword );
        return( leNew( "NIL" ));
    }

    for ( tryit=0 ; evalTable[tryit].word ; tryit++) {
        if (!strcmp(evalTable[tryit].word, keyword->data)) {
            leWipe( keyword );
            return( evalTable[tryit].callback(
                        lb,
                        countNodes( trybranch ),
                        trybranch) );
        }
    }

    leWipe( keyword );
    return( evaluateNode( lb, trybranch ));
}
예제 #2
0
le * eval_cb_car( lithp_burrito * lb, const int argc, le * branch )
{
    le * result = NULL;
    le * temp = NULL;
    if (!branch || argc != 2 ) return( leNew( "NIL" ));

    result = evaluateNode(lb, branch->list_next);

    if( result == NULL )  return( leNew( "NIL" ) );

    if (countNodes(result) <= 1) {
        if (result->branch) {
            temp = result;
            result = result->branch;
            temp->branch = NULL;
            leWipe( temp );
        }
        return( result );
    }

    result->list_next->list_prev = NULL;
    leWipe( result->list_next );
    result->list_next = NULL;

    if (result->branch) {
        temp = result;
        result = result->branch;
        temp->branch = NULL;
        leWipe( temp );
    }

    return( result );
}
예제 #3
0
le * eval_cb_enum( lithp_burrito * lb, const int argc, le * branch )
{
    le * current;
    int count = -1;
    char value[16];

    if (!branch || argc < 2)  return( leNew( "NIL" ) );

    current = branch->list_next;
    while ( current ) {
        if (current->data) {
            sprintf( value, "%d", ++count);

            lb->mainVarList = variableSetString(
                                  lb->mainVarList,
                                  current->data,
                                  value
                              );
        }
        current = current->list_next;
    }

    if (count == -1) return( leNew( "NIL" ) );
    else 		 return( evalCastIntToLe(count) );
}
예제 #4
0
le * eval_cb_cons( lithp_burrito * lb, const int argc, le * branch )
{
    le * result1 = NULL;
    le * result2 = NULL;

    if (!branch || argc != 3 ) return( leNew( "NIL" ));

    result1 = evaluateNode(lb, branch->list_next);
    if ( result1 == NULL ) return( leNew( "NIL" ));

    result2 = evaluateNode(lb, branch->list_next->list_next);
    if ( result2 == NULL ) {
        leWipe( result1 );
        return( leNew( "NIL" ));
    }

    if ( countNodes(result1) > 1 ) {
        le * temp = leNew( NULL );
        temp->branch = result1;
        result1 = temp;
    }
    result1->list_next = result2;
    result2->list_prev = result1;

    return( result1 );
}
예제 #5
0
le * eval_cb_whenunless_helper(
    enum whenunless which,
    lithp_burrito * lb, const int argc,
    le * branch
) {
    le * retval = NULL;
    le * trythis = NULL;

    if (!branch || argc < 3 ) return( leNew( "NIL" ));

    /* conditional */
    retval = evaluateNode(lb, branch->list_next);

    if ( which == WU_UNLESS )
    {
        /* unless - it wasn't true... bail */
        if ( strcmp( retval->data, "NIL" )) {
            leWipe( retval );
            return( leNew( "NIL" ) );
        }
    } else {
        /* when:   it wasn't false... bail */
        if ( !strcmp( retval->data, "NIL" ))
            return( retval );
    }

    trythis = branch->list_next->list_next;
    while( trythis ) {
        if (retval)  leWipe( retval );

        retval = evaluateNode(lb, trythis);
        trythis = trythis->list_next;
    }
    return( retval );
}
예제 #6
0
/* valid input:
	(DrawPen r g b m)
	(DrawPen (r g b m))
*/
le * eval_gfx_DrawPen ( lithp_burrito * lb, const int argc, le * branch )
{
    int r,g,b;
    int ac;
    le *mono, *result;

    if( !lb || !branch || (argc != 5 && argc != 2) )
        return( leNew( "NIL" ));

    if( argc == 5 ) {
        mono = eval_getint_3( lb, branch, &r, &g, &b );
        result = evaluateNode( lb, mono );
    } else {
        result = evaluateNode( lb, branch->list_next );

        ac = countNodes( result );
        if( ac != 4 ) return( leNew( "NIL" ));

        mono = eval_getint_3_noskip( lb, result, &r, &g, &b );
    }

    lb->pen1 = eval_make_color( lb, r, g, b, result->data );

    return( leNew( "T" ));
}
예제 #7
0
le * eval_cb_terpri( lithp_burrito * lb, const int argc, le * branch )
{
    if (!branch || argc != 1 ) return( leNew( "NIL" ));

    printf( "\n" );
    fflush( stdout );
    return( leNew( "NIL" ) );
}
예제 #8
0
le * eval_gfx_DrawFillEllipse ( lithp_burrito * lb, const int argc, le * branch )
{
    int x,y,a,b;
    if( !lb || !branch || argc != 5 ) return( leNew( "NIL" ));

    eval_getint_4( lb, branch, &x, &y, &a, &b );
    ttk_fillellipse( lb->srf, x, y, a, b, lb->pen1 );
    return( leNew( "T" ));
}
예제 #9
0
le * eval_gfx_DrawHGradient ( lithp_burrito * lb, const int argc, le * branch )
{
    int x,y,a,b;
    if( !lb || !branch || argc != 5 ) return( leNew( "NIL" ));

    eval_getint_4( lb, branch, &x, &y, &a, &b );
    ttk_hgradient( lb->srf, x, y, a, b, lb->pen1, lb->pen2 );
    return( leNew( "T" ));
}
예제 #10
0
le * eval_gfx_DrawPixel ( lithp_burrito * lb, const int argc, le * branch )
{
    int x,y;
    if( !lb || !branch || argc != 3 ) return( leNew( "NIL" ));

    eval_getint_2( lb, branch, &x, &y );
    ttk_pixel( lb->srf, x, y, lb->pen1 );
    return( leNew( "T" ));
}
예제 #11
0
le * evaluateDefun( lithp_burrito *lb, le * fcn, le * params )
{
    le * function;
    le * thisparam;
    le * result;
    int count;

    /* make sure both lists exist */
    if (!fcn)  return( leNew( "NIL" ));

    /* check for the correct number of parameters */
    if (countNodes(fcn->branch) > countNodes(params))
        return( leNew( "NIL" ));

    /* allocate another function definition, since we're gonna hack it */
    function = leDup(fcn);

    /* pass 1:  tag each node properly.
    	    for each parameter: (fcn)
    	    - look for it in the tree, tag those with the value
    */
    count = 0;
    thisparam = fcn->branch;
    while (thisparam)
    {
        leTagData(function, thisparam->data, count);
        thisparam = thisparam->list_next;
        count++;
    }

    /* pass 2:  replace
    	    for each parameter: (param)
    	    - evaluate the passed in value
    	    - replace it in the tree
    */
    count = 0;
    thisparam = params;
    while (thisparam)
    {
        result = evaluateNode( lb, thisparam );
        leTagReplace(function, count, result);
        thisparam = thisparam->list_next;
        leWipe(result);
        count++;
    }

    /* then evaluate the resulting tree */
    result = evaluateBranch( lb, function->list_next );

    /* free any space allocated */
    leWipe( function );

    /* return the evaluation */
    return( result );
}
예제 #12
0
le * eval_gfx_DrawPen2 ( lithp_burrito * lb, const int argc, le * branch )
{
    int r,g,b;
    le *mono, *result;
    if( !lb || !branch || argc != 5 ) return( leNew( "NIL" ));

    mono = eval_getint_3( lb, branch, &r, &g, &b );
    result = evaluateNode( lb, mono );
    lb->pen1 = eval_make_color( lb, r, g, b, result->data );
    return( leNew( "T" ));
}
예제 #13
0
le * eval_cb_require( lithp_burrito * lb, const int argc, le * branch )
{
    if (!branch || argc != 2) return( leNew( "NIL" ) );

    /* we should do different things based on this eventually... */
    if( !strcmp( branch->list_next->data, "pz2:0.8" )) {
        lb->apiVersion = 0.8;
        return( leNew( "T" ));
    }

    return( leNew( "NIL" ));
}
예제 #14
0
le * eval_gfx_DrawVectorTextCentered ( lithp_burrito * lb, const int argc, le * branch )
{
    int x,y,w,h;
    le *t, *t2;

    if( !lb || !branch || argc < 6 ) return( leNew( "NIL" ));
    t = eval_getint_4( lb, branch, &x, &y, &w, &h );
    t2 = evaluateNode( lb, t );

    pz_vector_string_center( lb->srf, t2->data, x, y, w, h, 1, lb->pen1 );

    return( leNew( "T" ));
}
예제 #15
0
le * eval_cb_atom( lithp_burrito * lb, const int argc, le * branch )
{
    le * result = NULL;
    if (!branch || argc != 2 ) return( leNew( "NIL" ));

    result = evaluateNode( lb, branch->list_next );

    if (countNodes(result) == 1) {
        leWipe( result );
        return( leNew( "T" ) );
    }
    return( leNew( "NIL" ) );
}
예제 #16
0
/* this is to be called like:  (RandomOf A B C D)
** although, it probably should be (RandomOf (list A B C D))
** this should work fine for now though
*/
le * eval_gfx_RandomOf( lithp_burrito * lb, const int argc, le * branch )
{
    le * ptr;
    int value;
    int r;

    if (!branch) return( leNew( "NIL" ) );
    value = (int)((float)(argc-1) * rand() / (RAND_MAX + 1.0));

    ptr = branch->list_next;
    for( r=0 ; r<value ; r++ ) ptr = ptr->list_next;

    return( leNew( ptr->data ));
}
예제 #17
0
le * eval_cb_defun( lithp_burrito * lb, const int argc, le * branch )
{
    if (!branch || argc < 4 ) return( leNew( "NIL" ));

    if ( !branch->list_next->data )  return( leNew( "NIL" ));

    lb->defunList = variableSet(
                        lb->defunList,
                        branch->list_next->data,
                        branch->list_next->list_next
                    );

    return( leNew( branch->list_next->data ));
}
예제 #18
0
le * evaluateNode( lithp_burrito * lb, le * node)
{
    le * temp;
    le * value;

    if (node->branch) {
        if( node->quoted ) {
            value = leDup( node->branch );
        } else {
            value = evaluateBranch( lb, node->branch );
        }
    } else {
        temp = variableGet( lb->defunList, node->data );

        if (temp) {
            value = evaluateDefun( lb, temp, node->list_next );
        } else {
            temp = variableGet( lb->mainVarList, node->data );
            if (temp) {
                value = leDup( temp );
            } else {
                value = leNew( node->data );
            }
        }
    }

    return( value );
}
예제 #19
0
le * eval_cb_multiply( lithp_burrito * lb, const int argc, le * branch )
{
    if (!branch || argc < 2) return( leNew( "NIL" ) );

    return( evalCastIntToLe(
                eval_cume_helper( C_MULTIPLY, lb, 1, branch->list_next)));
}
예제 #20
0
le * evalCastIntToLe( int intvalue )
{
    char buffer[80];
    sprintf (buffer, "%d", intvalue);

    return( leNew(buffer) );
}
예제 #21
0
static le *
evaluateBranch (le * trybranch)
{
  le *keyword;
  fentry * func;

  if (trybranch == NULL)
    return NULL;

  if (trybranch->branch)
    keyword = evaluateBranch (trybranch->branch);
  else
    keyword = leNew (trybranch->data);

  if (keyword->data == NULL)
    {
      leWipe (keyword);
      return leNIL;
    }

  func = get_fentry (keyword->data);
  leWipe (keyword);
  if (func)
    return func->func (1, false, trybranch);

  return NULL;
}
예제 #22
0
le * eval_cb_select( lithp_burrito * lb, const int argc, le * branch )
{
    le * result;

    if (argc < 2)  return( leNew( "NIL" ));

    branch = branch->list_next;
    result = evaluateNode(lb, branch);

    branch = branch->list_next;
    while( branch ) {
        if( branch->branch ) {
            le * check = branch->branch;
            if (check && check->data
                    && (!strcmp( check->data, result->data ))) {
                /* we're in the right place, evaluate and return */
                le * computelist = check->list_next;
                while( computelist )
                {
                    leWipe( result );
                    result = evaluateNode( lb, computelist );
                    computelist = computelist->list_next;
                }
                return( result );
            }
        }
        branch = branch->list_next;
    }

    return( result );
}
예제 #23
0
le * eval_cb_add( lithp_burrito * lb, const int argc, le * branch )
{
    if (!branch || argc < 2) return( leNew( "NIL" ) );

    return( evalCastIntToLe(
                eval_cume_helper( C_ADD, lb, 0, branch->list_next) ));
}
예제 #24
0
le * eval_cb_prog( lithp_burrito * lb, const int argc, le * branch, int returnit )
{
    le * curr;
    le * retval = NULL;
    le * tempval = NULL;
    int current = 0;

    if (!branch || argc < (returnit +1) ) return( leNew( "NIL" ));

    curr = branch->list_next;
    while (curr)
    {
        ++current;

        if ( tempval ) leWipe (tempval);
        tempval = evaluateNode( lb, curr );

        if (current == returnit) retval = leDup( tempval );

        curr = curr->list_next;
    }

    if (!retval)  retval = tempval;

    return( retval );
}
예제 #25
0
void variableSetString(le **varlist, char *key, char *value)
{
  if (key && value) {
    le *temp = leNew(value);
    variableSet(varlist, key, temp);
    leWipe(temp);
  }
}
예제 #26
0
le * eval_cb_eqsign( lithp_burrito * lb, const int argc, le * branch )
{
    le * letemp;
    int value1, value2;

    if (!branch || argc != 3 ) return( leNew( "NIL" ) );

    letemp = evaluateNode( lb, branch->list_next );
    value1 = evalCastLeToInt( letemp );
    leWipe( letemp );

    letemp = evaluateNode( lb, branch->list_next->list_next );
    value2 = evalCastLeToInt( letemp );
    leWipe( letemp );

    return( leNew ( (value1 == value2 )?"T":"NIL" ) );
}
예제 #27
0
le * eval_cb_equal( lithp_burrito * lb, const int argc, le * branch )
{
    le * list1 = NULL;
    le * list2 = NULL;
    int retval = 0;

    if (!branch || argc != 3 ) return( leNew( "NIL" ) );

    list1 = evaluateNode( lb, branch->list_next );
    list2 = evaluateNode( lb, branch->list_next->list_next );

    retval = eval_cb_lists_same( list1, list2 );

    leWipe( list1 );
    leWipe( list2 );

    return( leNew ( (retval == 1) ? "T" : "NIL" ) );
}
예제 #28
0
le * eval_gfx_RangeWrap( lithp_burrito * lb, const int argc, le * branch )
{
    int v, min, max;
    if (!branch || argc != 4) return( leNew( "NIL" ) );

    (void)eval_getint_3( lb, branch, &v, &min, &max );
    if( v>max ) v=min;
    if( v<min ) v=max;
    return( evalCastIntToLe( v ) );
}
예제 #29
0
le * eval_cb_eval( lithp_burrito * lb, const int argc, le * branch )
{
    le * temp;
    le * retval;
    if (!branch || argc != 2 ) return( leNew( "NIL" ));

    temp = evaluateNode(lb, branch->list_next);
    retval = evaluateBranch(lb, temp);
    leWipe( temp );
    return( retval );
}
예제 #30
0
le * eval_cb_list( lithp_burrito * lb, const int argc, le * branch )
{
    le * currelement = NULL;
    le * finaltree = NULL;
    le * lastadded = NULL;
    le * result = NULL;

    if (!branch) return( leNew( "NIL" ));

    currelement = branch->list_next;
    while (currelement)
    {
        result = evaluateNode(lb, currelement);
        if ( result == NULL ) {
            leWipe( finaltree );
            return( leNew( "NIL" ));
        }

        if( countNodes(result) > 1) {
            le * temp = leNew( NULL );
            temp->branch = result;
            result = temp;
        }

        if (!finaltree) {
            finaltree = result;
            lastadded = result;
        } else {
            lastadded->list_next = result;
            result->list_prev    = lastadded;
            lastadded = result;
        }

        currelement = currelement->list_next;
    }

    if (!finaltree) {
        return( leNew( "NIL" ));
    }
    return( finaltree );
}