home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 2002 April / pcpro0402.iso / essentials / graphics / Gimp / gimp-src-20001226.exe / src / gimp / unofficial-plug-ins / mathmap / postfix.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-04-21  |  12.1 KB  |  523 lines
  1. /*
  2.  * postfix.c
  3.  *
  4.  * MathMap
  5.  *
  6.  * Copyright (C) 1997-2000 Mark Probst
  7.  *
  8.  * This program is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU General Public License
  10.  * as published by the Free Software Foundation; either version 2
  11.  * of the License, or (at your option) any later version.
  12.  *
  13.  * This program is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  * GNU General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU General Public License
  19.  * along with this program; if not, write to the Free Software
  20.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  */
  22.  
  23. #include <stdio.h>
  24. #include <math.h>
  25. #include <string.h>
  26. #include <assert.h>
  27.  
  28. #include "builtins.h"
  29. #include "vars.h"
  30. #include "exprtree.h"
  31. #include "tags.h"
  32. #include "tuples.h"
  33. #include "overload.h"
  34. #include "mathmap.h"
  35. #include "jump.h"
  36. #include "userval.h"
  37.  
  38. #include "postfix.h"
  39.  
  40. #define STACKSIZE    1024
  41. #define EXPRSIZE     8192
  42.  
  43. extern int usesRA;
  44.  
  45. tuple_t stack[STACKSIZE];
  46. int stackp,
  47.     num_ops = 0;
  48.  
  49. postfix expression[EXPRSIZE];
  50. int exprp,
  51.     exprlen;
  52.  
  53. void
  54. stack_push (postfix_arg *arg)
  55. {
  56.     stack[stackp] = arg->tuple;
  57.     ++stackp;
  58. }
  59.  
  60. void
  61. stack_pop (postfix_arg *arg)
  62. {
  63.     --stackp;
  64. }
  65.  
  66. void
  67. stack_select (postfix_arg *arg)
  68. {
  69.     tuple_t result;
  70.     int i;
  71.  
  72.     for (i = 0; i < stack[stackp - 1].length; ++i)
  73.     {
  74.     int index = stack[stackp - 1].data[i];
  75.  
  76.     if (index < 0 || index >= stack[stackp - 2].length)
  77.         result.data[i] = 0.0;
  78.     else
  79.         result.data[i] = stack[stackp - 2].data[index];
  80.     }
  81.  
  82.     memcpy(stack[stackp - 2].data, result.data, sizeof(float) * stack[stackp - 1].length);
  83.     if (stack[stackp - 1].length == 1)
  84.     stack[stackp - 2].number = nil_tag_number;
  85.     stack[stackp - 2].length = stack[stackp - 1].length;
  86.     --stackp;
  87. }
  88.  
  89. void
  90. stack_tuple (postfix_arg *arg)
  91. {
  92.     int i;
  93.  
  94.     for (i = 1; i < arg->integer; ++i)
  95.     stack[stackp - arg->integer].data[i] = stack[stackp - arg->integer + i].data[0];
  96.     stack[stackp - arg->integer].number = nil_tag_number;
  97.     stack[stackp - arg->integer].length = arg->integer;
  98.  
  99.     stackp -= arg->integer - 1;
  100. }
  101.  
  102. void
  103. stack_dupn_i (postfix_arg *arg)
  104. {
  105.     int i;
  106.  
  107.     for (i = 0; i < arg->integer; ++i)
  108.     stack[stackp + i] = stack[stackp - 1];
  109.  
  110.     stackp += arg->integer;
  111. }
  112.  
  113. void
  114. stack_cast (postfix_arg *arg)
  115. {
  116.     stack[stackp - 1].number = arg->integer;
  117. }
  118.  
  119. void
  120. stack_jmp (postfix_arg *arg)
  121. {
  122.     exprp = arg->integer - 1;
  123. }
  124.  
  125. void
  126. stack_jez (postfix_arg *arg)
  127. {
  128.     if (stack[--stackp].data[0] == 0.0)
  129.     exprp = arg->integer - 1;
  130. }
  131.  
  132. void
  133. stack_jnez (postfix_arg *arg)
  134. {
  135.     if (stack[--stackp].data[0] != 0.0)
  136.     exprp = arg->integer - 1;
  137. }
  138.  
  139. void
  140. stack_push_internal (postfix_arg *arg)
  141. {
  142.     stack[stackp++] = arg->internal->value;
  143. }
  144.  
  145. void
  146. stack_push_user_var (postfix_arg *arg)
  147. {
  148.     stack[stackp++] = arg->user_var->value;
  149. }
  150.  
  151. void
  152. stack_assign (postfix_arg *arg)
  153. {
  154.     arg->user_var->value = stack[stackp - 1];
  155. }
  156.  
  157. void
  158. stack_sub_assign (postfix_arg *arg)
  159. {
  160.     int i;
  161.  
  162.     for (i = 0; i < stack[stackp - 1].length; ++i)
  163.     {
  164.     int index = (int)stack[stackp - 1].data[i];
  165.  
  166.     if (index >= 0 && index < arg->user_var->value.length)
  167.         arg->user_var->value.data[index] = stack[stackp - 2].data[i];
  168.     }
  169.     --stackp;
  170. }
  171.  
  172. void
  173. stack_userval_slider (postfix_arg *arg)
  174. {
  175.     stack[stackp].data[0] = arg->userval->v.slider.value;
  176.     stack[stackp].length = 1;
  177.     stack[stackp].number = nil_tag_number;
  178.     ++stackp;
  179. }
  180.  
  181. void
  182. stack_userval_bool (postfix_arg *arg)
  183. {
  184.     stack[stackp].data[0] = arg->userval->v.bool.value;
  185.     stack[stackp].length = 1;
  186.     stack[stackp].number = nil_tag_number;
  187.     ++stackp;
  188. }
  189.  
  190. void
  191. stack_userval_color (postfix_arg *arg)
  192. {
  193.     stack[stackp++] = arg->userval->v.color.value;
  194. }
  195.  
  196. void
  197. stack_userval_curve (postfix_arg *arg)
  198. {
  199.     int index = stack[stackp - 1].data[0] * (USER_CURVE_POINTS - 1);
  200.  
  201.     if (index < 0)
  202.     index = 0;
  203.     else if (index >= USER_CURVE_POINTS)
  204.     index = USER_CURVE_POINTS - 1;
  205.  
  206.     stack[stackp - 1].data[0] = arg->userval->v.curve.values[index];
  207.     stack[stackp - 1].number = nil_tag_number;
  208. }
  209.  
  210. void
  211. stack_userval_image (postfix_arg *arg)
  212. {
  213.     stack[stackp].data[0] = arg->userval->v.image.index;
  214.     stack[stackp].length = 1;
  215.     stack[stackp].number = image_tag_number;
  216.     ++stackp;
  217. }
  218.  
  219. void
  220. make_postfix_recursive (exprtree *tree)
  221. {
  222.     switch (tree->type)
  223.     {
  224.     case EXPR_TUPLE_CONST :
  225.         expression[exprp].func = stack_push;
  226.         expression[exprp].arg.tuple = tree->val.tuple_const;
  227.         ++exprp;
  228.         break;
  229.  
  230.     case EXPR_TUPLE :
  231.         {
  232.         exprtree *elem;
  233.  
  234.         for (elem = tree->val.tuple.elems; elem != 0; elem = elem->next)
  235.             make_postfix_recursive(elem);
  236.  
  237.         expression[exprp].func = stack_tuple;
  238.         expression[exprp].arg.integer = tree->val.tuple.length;
  239.         ++exprp;
  240.         }
  241.         break;
  242.  
  243.     case EXPR_SELECT :
  244.         make_postfix_recursive(tree->val.select.tuple);
  245.         make_postfix_recursive(tree->val.select.subscripts);
  246.         expression[exprp].func = stack_select;
  247.         ++exprp;
  248.         break;
  249.  
  250.     case EXPR_CAST :
  251.         make_postfix_recursive(tree->val.cast.tuple);
  252.         if (tree->val.cast.tuple->result.number != tree->val.cast.tagnum)
  253.         {
  254.         expression[exprp].func = stack_cast;
  255.         expression[exprp].arg.integer = tree->val.cast.tagnum;
  256.         ++exprp;
  257.         }
  258.         break;
  259.  
  260.     case EXPR_INTERNAL :
  261.         expression[exprp].func = stack_push_internal;
  262.         expression[exprp].arg.internal = tree->val.internal;
  263.         ++exprp;
  264.         break;
  265.  
  266.     case EXPR_FUNC :
  267.         {
  268.         exprtree *arg = tree->val.func.args;
  269.  
  270.         while (arg != 0)
  271.         {
  272.             make_postfix_recursive(arg);
  273.             arg = arg->next;
  274.         }
  275.  
  276.         expression[exprp++].func = tree->val.func.entry->v.builtin.builtin;
  277.  
  278.         }
  279.         break;
  280.  
  281.     case EXPR_VARIABLE :
  282.         assert(tree->val.var->value.length != 0);
  283.         expression[exprp].func = stack_push_user_var;
  284.         expression[exprp].arg.user_var = tree->val.var;
  285.         ++exprp;
  286.         break;
  287.  
  288.     case EXPR_USERVAL :
  289.         if (tree->val.userval.userval->type == USERVAL_SLIDER)
  290.         expression[exprp].func = stack_userval_slider;
  291.         else if (tree->val.userval.userval->type == USERVAL_BOOL)
  292.         expression[exprp].func = stack_userval_bool;
  293.         else if (tree->val.userval.userval->type == USERVAL_COLOR)
  294.         expression[exprp].func = stack_userval_color;
  295.         else if (tree->val.userval.userval->type == USERVAL_CURVE)
  296.         {
  297.         make_postfix_recursive(tree->val.userval.args);
  298.         expression[exprp].func = stack_userval_curve;
  299.         }
  300.         else if (tree->val.userval.userval->type == USERVAL_IMAGE)
  301.         expression[exprp].func = stack_userval_image;
  302.         else
  303.         assert(0);
  304.         expression[exprp].arg.userval = tree->val.userval.userval;
  305.         ++exprp;
  306.         break;
  307.  
  308.     case EXPR_ASSIGNMENT :
  309.         make_postfix_recursive(tree->val.assignment.value);
  310.  
  311.         expression[exprp].func = stack_assign;
  312.         expression[exprp].arg.user_var = tree->val.assignment.var;
  313.         ++exprp;
  314.         break;
  315.  
  316.     case EXPR_SUB_ASSIGNMENT :
  317.         make_postfix_recursive(tree->val.sub_assignment.value);
  318.         make_postfix_recursive(tree->val.sub_assignment.subscripts);
  319.  
  320.         expression[exprp].func = stack_sub_assign;
  321.         expression[exprp].arg.user_var = tree->val.sub_assignment.var;
  322.         ++exprp;
  323.         break;
  324.  
  325.     case EXPR_SEQUENCE :
  326.         make_postfix_recursive(tree->val.operator.left);
  327.         expression[exprp++].func = stack_pop;
  328.         make_postfix_recursive(tree->val.operator.right);
  329.         break;
  330.  
  331.     case EXPR_IF_THEN :
  332.         {
  333.         int jump_pos1,
  334.             jump_pos2,
  335.             i;
  336.  
  337.         make_postfix_recursive(tree->val.ifExpr.condition);
  338.         expression[exprp].func = stack_jez;
  339.         jump_pos1 = exprp;
  340.         ++exprp;
  341.         make_postfix_recursive(tree->val.ifExpr.consequent);
  342.         expression[exprp].func = stack_jmp;
  343.         jump_pos2 = exprp;
  344.         ++exprp;
  345.         expression[jump_pos1].arg.integer = exprp;
  346.         expression[exprp].func = stack_push;
  347.         expression[exprp].arg.tuple.number = tree->result.number;
  348.         expression[exprp].arg.tuple.length = tree->result.length;
  349.         for (i = 0; i < tree->result.length; ++i)
  350.             expression[exprp].arg.tuple.data[i] = 0.0;
  351.         ++exprp;
  352.         expression[jump_pos2].arg.integer = exprp;
  353.         }
  354.         break;
  355.  
  356.     case EXPR_IF_THEN_ELSE :
  357.         {
  358.         int jump_pos1,
  359.             jump_pos2;
  360.  
  361.         make_postfix_recursive(tree->val.ifExpr.condition);
  362.         expression[exprp].func = stack_jez;
  363.         jump_pos1 = exprp;
  364.         ++exprp;
  365.         make_postfix_recursive(tree->val.ifExpr.consequent);
  366.         expression[exprp].func = stack_jmp;
  367.         jump_pos2 = exprp;
  368.         ++exprp;
  369.         expression[jump_pos1].arg.integer = exprp;
  370.         make_postfix_recursive(tree->val.ifExpr.alternative);
  371.         expression[jump_pos2].arg.integer = exprp;
  372.         }
  373.         break;
  374.  
  375.     case EXPR_WHILE :
  376.         {
  377.         int label1,
  378.             jump_pos2;
  379.  
  380.         label1 = exprp;
  381.         make_postfix_recursive(tree->val.whileExpr.invariant);
  382.         expression[exprp].func = stack_jez;
  383.         jump_pos2 = exprp;
  384.         ++exprp;
  385.         make_postfix_recursive(tree->val.whileExpr.body);
  386.         expression[exprp++].func = stack_pop;
  387.         expression[exprp].func = stack_jmp;
  388.         expression[exprp].arg.integer = label1;
  389.         ++exprp;
  390.         expression[jump_pos2].arg.integer = exprp;
  391.         expression[exprp].func = stack_push;
  392.         expression[exprp].arg.tuple.number = nil_tag_number;
  393.         expression[exprp].arg.tuple.length = 1;
  394.         expression[exprp].arg.tuple.data[0] = 0.0;
  395.         ++exprp;
  396.         }
  397.         break;
  398.  
  399.     case EXPR_DO_WHILE :
  400.         {
  401.         int label;
  402.  
  403.         label = exprp;
  404.         make_postfix_recursive(tree->val.whileExpr.body);
  405.         expression[exprp++].func = stack_pop;
  406.         make_postfix_recursive(tree->val.whileExpr.invariant);
  407.         expression[exprp].func = stack_jnez;
  408.         expression[exprp].arg.integer = label;
  409.         ++exprp;
  410.         expression[exprp].func = stack_push;
  411.         expression[exprp].arg.tuple.number = nil_tag_number;
  412.         expression[exprp].arg.tuple.length = 1;
  413.         expression[exprp].arg.tuple.data[0] = 0.0;
  414.         ++exprp;
  415.         }
  416.         break;
  417.  
  418.     default :
  419.         fprintf(stderr, "illegal expr\n");
  420.         break;
  421.     }
  422. }
  423.  
  424. void
  425. make_postfix (exprtree *tree)
  426. {
  427.     exprp = 0;
  428.     make_postfix_recursive(tree);
  429.     exprlen = exprp;
  430. }
  431.  
  432. void
  433. make_empty_postfix (void)
  434. {
  435.     int i;
  436.  
  437.     expression[0].func = stack_push;
  438.     expression[0].arg.tuple.number = rgba_tag_number;
  439.     expression[0].arg.tuple.length = 4;
  440.     for (i = 0; i < 4; ++i)
  441.     expression[0].arg.tuple.data[i] = 0.0;
  442.  
  443.     exprlen = exprp = 1;
  444. }
  445.  
  446. void
  447. output_tuple (tuple_t *tuple)
  448. {
  449.     int i;
  450.  
  451.     printf("%s:[", tag_name_for_number(tuple->number));
  452.     for (i = 0; i < tuple->length; ++i)
  453.     printf(i == tuple->length - 1 ? "%f]" : "%f,", tuple->data[i]);
  454. }
  455.  
  456. void
  457. output_postfix (void)
  458. {
  459.     int i;
  460.  
  461.     printf("-------------------------\n");
  462.  
  463.     for (i = 0; i < exprlen; ++i)
  464.     {
  465.     printf("%3d   ", i);
  466.     if (expression[i].func == stack_push)
  467.     {
  468.         printf("push ");
  469.         output_tuple(&expression[i].arg.tuple);
  470.         printf("\n");
  471.     }
  472.     else if (expression[i].func == stack_pop)
  473.         printf("pop\n");
  474.     else if (expression[i].func == stack_select)
  475.         printf("select\n");
  476.     else if (expression[i].func == stack_tuple)
  477.         printf("tuple %d\n", expression[i].arg.integer);
  478.     else if (expression[i].func == stack_dupn_i)
  479.         printf("dupn_i %d\n", expression[i].arg.integer);
  480.     else if (expression[i].func == stack_cast)
  481.         printf("cast %s\n", tag_name_for_number(expression[i].arg.integer));
  482.     else if (expression[i].func == stack_jmp)
  483.         printf("jmp %d\n", expression[i].arg.integer);
  484.     else if (expression[i].func == stack_jez)
  485.         printf("jez %d\n", expression[i].arg.integer);
  486.     else if (expression[i].func == stack_jnez)
  487.         printf("jnez %d\n", expression[i].arg.integer);
  488.     else if (expression[i].func == stack_push_internal)
  489.         printf("push_internal %s\n", expression[i].arg.internal->name);
  490.     else if (expression[i].func == stack_push_user_var)
  491.         printf("push_user_var %s\n", expression[i].arg.user_var->name);
  492.     else if (expression[i].func == stack_assign)
  493.         printf("sto %s\n", expression[i].arg.user_var->name);
  494.     else if (expression[i].func == stack_sub_assign)
  495.         printf("substo %s\n", expression[i].arg.user_var->name);
  496.     else
  497.     {
  498.         overload_entry_t *entry = overloaded_builtin_with_function(expression[i].func);
  499.  
  500.         if (entry != 0)
  501.         printf("%s\n", entry->name);
  502.         else
  503.         printf("unknown opcode\n");
  504.     }
  505.     }
  506. }
  507.  
  508. tuple_t*
  509. eval_postfix (void)
  510. {
  511.     stackp = 0;
  512.     for (exprp = 0; exprp < exprlen; ++exprp)
  513.     {
  514.     expression[exprp].func(&expression[exprp].arg);
  515.     ++num_ops;
  516.     }
  517.  
  518.     stack[0].number = rgba_tag_number;
  519.     stack[0].length = 4;
  520.  
  521.     return &stack[0];
  522. }
  523.