Mercurial > hg > dav / file comparison

comparison: libidav/davqlexec.c

libidav/davqlexec.c

changeset 135
664aeaec8d25
parent 134
4bccc18820e8
child 136
59058927b885
equal deleted inserted replaced
134:4bccc18820e8 135:664aeaec8d25
36 #include "utils.h" 36 #include "utils.h"
37 #include "methods.h" 37 #include "methods.h"
38 #include "session.h" 38 #include "session.h"
39 #include "resource.h" 39 #include "resource.h"
40 40
41 DavResult* dav_statement_exec(DavSession *sn, DavQLStatement *st, ...) { 41 DavResult dav_statement_exec(DavSession *sn, DavQLStatement *st, ...) {
42 va_list ap; 42 va_list ap;
43 va_start(ap, st); 43 va_start(ap, st);
44 DavResult *result = dav_statement_execv(sn, st, ap); 44 DavResult result = dav_statement_execv(sn, st, ap);
45 va_end(ap); 45 va_end(ap);
46 return result; 46 return result;
47 } 47 }
48 48
49 DavResult* dav_statement_execv(DavSession *sn, DavQLStatement *st, va_list ap) { 49 DavResult dav_statement_execv(DavSession *sn, DavQLStatement *st, va_list ap) {
50 DavResult *result = dav_session_malloc(sn, sizeof(DavResult)); 50 DavResult result;
51 result->result = NULL; 51 result.result = NULL;
52 result->status = 1; 52 result.status = 1;
53 53
54 // make sure the statement was successfully parsed 54 // make sure the statement was successfully parsed
55 if(st->type == DAVQL_ERROR) { 55 if(st->type == DAVQL_ERROR) {
56 DavResult result;
56 return result; 57 return result;
57 } 58 }
58 59
59 // get path string
60 davqlerror_t error;
61 sstr_t path = dav_format_string(sn->mp->allocator, st->path, ap, &error);
62
63 if(st->type == DAVQL_SELECT) { 60 if(st->type == DAVQL_SELECT) {
64 *result = dav_exec_select(sn, st, path.ptr, ap); 61 return dav_exec_select(sn, st, ap);
65 } else { 62 } else {
66 // TODO 63 // TODO
67 } 64 }
68 65
69 return result; 66 return result;
201 ucx_list_free(list); 198 ucx_list_free(list);
202 return reqbuf; 199 return reqbuf;
203 } 200 }
204 201
205 static int reset_properties(DavSession *sn, DavResult *result, DavResource *res, UcxList *fields) { 202 static int reset_properties(DavSession *sn, DavResult *result, DavResource *res, UcxList *fields) {
203 return 0;
206 UcxMap *new_properties = ucx_map_new_a(sn->mp->allocator, 32); 204 UcxMap *new_properties = ucx_map_new_a(sn->mp->allocator, 32);
207 DavResourceData *data = (DavResourceData*)res->data; 205 DavResourceData *data = (DavResourceData*)res->data;
208 206
209 // add basic properties 207 // add basic properties
210 char *value; 208 char *value;
293 } 291 }
294 292
295 /* 293 /*
296 * execute a davql select statement 294 * execute a davql select statement
297 */ 295 */
298 DavResult dav_exec_select(DavSession *sn, DavQLStatement *st, char* path, va_list ap) { 296 DavResult dav_exec_select(DavSession *sn, DavQLStatement *st, va_list ap) {
299 UcxMempool *mp = ucx_mempool_new(128); 297 UcxMempool *mp = ucx_mempool_new(128);
300 DavResult result; 298 DavResult result;
301 result.result = NULL; 299 result.result = NULL;
302 result.status = 1; 300 result.status = 1;
303 301
343 cfield->code = code; 341 cfield->code = code;
344 cfieldlist = ucx_list_append_a(mp->allocator, cfieldlist, cfield); 342 cfieldlist = ucx_list_append_a(mp->allocator, cfieldlist, cfield);
345 } 343 }
346 } 344 }
347 345
346 // get path string
347 davqlerror_t error;
348 sstr_t path = dav_format_string(mp->allocator, st->path, ap, &error);
349 if(error) {
350 // TODO: cleanup
351 return result;
352 }
353
354 int depth = st->depth == DAV_DEPTH_PLACEHOLDER ? va_arg(ap, int) : st->depth;
355
348 UcxBuffer *where = dav_compile_expr(sn->context, mp->allocator, st->where, ap); 356 UcxBuffer *where = dav_compile_expr(sn->context, mp->allocator, st->where, ap);
349 if(!where) { 357 if(st->where && !where) {
350 ucx_mempool_destroy(mp); 358 ucx_mempool_destroy(mp);
351 return result; 359 return result;
352 } 360 }
353 361
354 DavResource *selroot = dav_resource_new(sn, path); 362 DavResource *selroot = dav_resource_new(sn, path.ptr);
355 363
356 UcxList *stack = NULL; // stack with DavResource* elements 364 UcxList *stack = NULL; // stack with DavResource* elements
357 // initialize the stack with the requested resource 365 // initialize the stack with the requested resource
358 DavQLRes *r = ucx_mempool_malloc(mp, sizeof(DavQLRes)); 366 DavQLRes *r = ucx_mempool_malloc(mp, sizeof(DavQLRes));
359 r->resource = selroot; 367 r->resource = selroot;
429 if(!dav_exec_expr(where, child, &where_result)) { 437 if(!dav_exec_expr(where, child, &where_result)) {
430 if(where_result.data.integer != 0) { 438 if(where_result.data.integer != 0) {
431 if(!reset_properties(sn, &result, child, cfieldlist)) { 439 if(!reset_properties(sn, &result, child, cfieldlist)) {
432 resource_add_child(root, child); 440 resource_add_child(root, child);
433 if(child->iscollection && 441 if(child->iscollection &&
434 (st->depth < 0 || st->depth > sr->depth+1)) 442 (depth < 0 || depth > sr->depth+1))
435 { 443 {
436 DavQLRes *rs = ucx_mempool_malloc( 444 DavQLRes *rs = ucx_mempool_malloc(
437 mp, 445 mp,
438 sizeof(DavQLRes)); 446 sizeof(DavQLRes));
439 rs->resource = child; 447 rs->resource = child;
513 ucx_buffer_write(&cmd, sizeof(cmd), 1, bcode); 521 ucx_buffer_write(&cmd, sizeof(cmd), 1, bcode);
514 break; 522 break;
515 } 523 }
516 case DAVQL_TIMESTAMP: { 524 case DAVQL_TIMESTAMP: {
517 if(src.ptr[0] == '%') { 525 if(src.ptr[0] == '%') {
526 cmd.type = DAVQL_CMD_TIMESTAMP;
518 cmd.data.timestamp = va_arg(ap, time_t); 527 cmd.data.timestamp = va_arg(ap, time_t);
519 ucx_buffer_write(&cmd, sizeof(cmd), 1, bcode); 528 ucx_buffer_write(&cmd, sizeof(cmd), 1, bcode);
520 } else { 529 } else {
521 // error 530 // error
522 return -1; 531 return -1;
762 771
763 return bcode; 772 return bcode;
764 } 773 }
765 774
766 int dav_exec_expr(UcxBuffer *bcode, DavResource *res, DavQLStackObj *result) { 775 int dav_exec_expr(UcxBuffer *bcode, DavResource *res, DavQLStackObj *result) {
776 if(!bcode) {
777 result->type = 0;
778 result->length = 0;
779 result->data.integer = 1;
780 return 0;
781 }
782
767 size_t count = bcode->pos / sizeof(DavQLCmd); 783 size_t count = bcode->pos / sizeof(DavQLCmd);
768 DavQLCmd *cmds = (DavQLCmd*)bcode->space; 784 DavQLCmd *cmds = (DavQLCmd*)bcode->space;
769 785
770 // create execution stack 786 // create execution stack
771 size_t stsize = 64; 787 size_t stsize = 64;
791 int ret = 0; 807 int ret = 0;
792 for(size_t i=0;i<count;i++) { 808 for(size_t i=0;i<count;i++) {
793 DavQLCmd cmd = cmds[i]; 809 DavQLCmd cmd = cmds[i];
794 switch(cmd.type) { 810 switch(cmd.type) {
795 case DAVQL_CMD_INT: { 811 case DAVQL_CMD_INT: {
796 printf("int %lld\n", cmd.data.integer); 812 //printf("int %lld\n", cmd.data.integer);
797 obj.type = 0; 813 obj.type = 0;
798 obj.length = 0; 814 obj.length = 0;
799 obj.data.integer = cmd.data.integer; 815 obj.data.integer = cmd.data.integer;
800 DAVQL_PUSH(obj); 816 DAVQL_PUSH(obj);
801 break; 817 break;
802 } 818 }
803 case DAVQL_CMD_STRING: { 819 case DAVQL_CMD_STRING: {
804 printf("string \"%.*s\"\n", cmd.data.string.length, cmd.data.string.ptr); 820 //printf("string \"%.*s\"\n", cmd.data.string.length, cmd.data.string.ptr);
805 obj.type = 1; 821 obj.type = 1;
806 obj.length = cmd.data.string.length; 822 obj.length = cmd.data.string.length;
807 obj.data.string = cmd.data.string.ptr; 823 obj.data.string = cmd.data.string.ptr;
808 DAVQL_PUSH(obj); 824 DAVQL_PUSH(obj);
809 break; 825 break;
810 } 826 }
811 case DAVQL_CMD_TIMESTAMP: { 827 case DAVQL_CMD_TIMESTAMP: {
812 printf("timestamp %d\n", cmd.data.timestamp); 828 //printf("timestamp %d\n", cmd.data.timestamp);
813 obj.type = 0; 829 obj.type = 0;
814 obj.length = 0; 830 obj.length = 0;
815 obj.data.integer = cmd.data.timestamp; 831 obj.data.integer = (int)cmd.data.timestamp;
816 DAVQL_PUSH(obj); 832 DAVQL_PUSH(obj);
817 break; 833 break;
818 } 834 }
819 case DAVQL_CMD_RES_IDENTIFIER: { 835 case DAVQL_CMD_RES_IDENTIFIER: {
820 char *rid[8] = {"name", "path", "href", "contentlength", "contenttype", "creationdate", "lastmodified", "iscollection"}; 836 char *rid[8] = {"name", "path", "href", "contentlength", "contenttype", "creationdate", "lastmodified", "iscollection"};
821 printf("resprop %s\n", rid[cmd.data.resprop]); 837 //printf("resprop %s\n", rid[cmd.data.resprop]);
822 switch(cmd.data.resprop) { 838 switch(cmd.data.resprop) {
823 case DAVQL_RES_NAME: { 839 case DAVQL_RES_NAME: {
824 obj.type = 1; 840 obj.type = 1;
825 obj.length = strlen(res->name); 841 obj.length = strlen(res->name);
826 obj.data.string = res->name; 842 obj.data.string = res->name;
871 } 887 }
872 DAVQL_PUSH(obj); 888 DAVQL_PUSH(obj);
873 break; 889 break;
874 } 890 }
875 case DAVQL_CMD_PROP_IDENTIFIER: { 891 case DAVQL_CMD_PROP_IDENTIFIER: {
876 printf("property %s:%s\n", cmd.data.property.ns, cmd.data.property.name); 892 //printf("property %s:%s\n", cmd.data.property.ns, cmd.data.property.name);
877 char *value = dav_get_property_ns(res, cmd.data.property.ns, cmd.data.property.name); 893 char *value = dav_get_property_ns(res, cmd.data.property.ns, cmd.data.property.name);
878 obj.type = 1; 894 obj.type = 1;
879 obj.length = value ? strlen(value) : 0; 895 obj.length = value ? strlen(value) : 0;
880 obj.data.string = value; 896 obj.data.string = value;
881 DAVQL_PUSH(obj); 897 DAVQL_PUSH(obj);
884 //case DAVQL_CMD_OP_UNARY_ADD: { 900 //case DAVQL_CMD_OP_UNARY_ADD: {
885 // printf("uadd\n"); 901 // printf("uadd\n");
886 // break; 902 // break;
887 //} 903 //}
888 case DAVQL_CMD_OP_UNARY_SUB: { 904 case DAVQL_CMD_OP_UNARY_SUB: {
889 printf("usub\n"); 905 //printf("usub\n");
890 obj = DAVQL_POP(); 906 obj = DAVQL_POP();
891 if(obj.type == 0) { 907 if(obj.type == 0) {
892 obj.data.integer = -obj.data.integer; 908 obj.data.integer = -obj.data.integer;
893 DAVQL_PUSH(obj); 909 DAVQL_PUSH(obj);
894 } else { 910 } else {
896 i = count; // end loop 912 i = count; // end loop
897 } 913 }
898 break; 914 break;
899 } 915 }
900 case DAVQL_CMD_OP_UNARY_NEG: { 916 case DAVQL_CMD_OP_UNARY_NEG: {
901 printf("uneg\n"); 917 //printf("uneg\n");
902 obj = DAVQL_POP(); 918 obj = DAVQL_POP();
903 if(obj.type == 0) { 919 if(obj.type == 0) {
904 obj.data.integer = obj.data.integer == 0 ? 1 : 0; 920 obj.data.integer = obj.data.integer == 0 ? 1 : 0;
905 DAVQL_PUSH(obj); 921 DAVQL_PUSH(obj);
906 } else { 922 } else {
908 i = count; // end loop 924 i = count; // end loop
909 } 925 }
910 break; 926 break;
911 } 927 }
912 case DAVQL_CMD_OP_BINARY_ADD: { 928 case DAVQL_CMD_OP_BINARY_ADD: {
913 printf("add\n"); 929 //printf("add\n");
914 DavQLStackObj obj2 = DAVQL_POP(); 930 DavQLStackObj obj2 = DAVQL_POP();
915 DavQLStackObj obj1 = DAVQL_POP(); 931 DavQLStackObj obj1 = DAVQL_POP();
916 if(obj1.type == 0 && obj2.type == 0) { 932 if(obj1.type == 0 && obj2.type == 0) {
917 DAVQL_PUSH_INT(obj1.data.integer + obj2.data.integer); 933 DAVQL_PUSH_INT(obj1.data.integer + obj2.data.integer);
918 } else { 934 } else {
919 // TODO: string concat 935 // TODO: string concat
920 } 936 }
921 break; 937 break;
922 } 938 }
923 case DAVQL_CMD_OP_BINARY_SUB: { 939 case DAVQL_CMD_OP_BINARY_SUB: {
924 printf("sub\n"); 940 //printf("sub\n");
925 DavQLStackObj obj2 = DAVQL_POP(); 941 DavQLStackObj obj2 = DAVQL_POP();
926 DavQLStackObj obj1 = DAVQL_POP(); 942 DavQLStackObj obj1 = DAVQL_POP();
927 if(obj1.type == 0 && obj2.type == 0) { 943 if(obj1.type == 0 && obj2.type == 0) {
928 DAVQL_PUSH_INT(obj1.data.integer - obj2.data.integer); 944 DAVQL_PUSH_INT(obj1.data.integer - obj2.data.integer);
929 } else { 945 } else {
932 i = count; // end loop 948 i = count; // end loop
933 } 949 }
934 break; 950 break;
935 } 951 }
936 case DAVQL_CMD_OP_BINARY_MUL: { 952 case DAVQL_CMD_OP_BINARY_MUL: {
937 printf("mul\n"); 953 //printf("mul\n");
938 DavQLStackObj obj2 = DAVQL_POP(); 954 DavQLStackObj obj2 = DAVQL_POP();
939 DavQLStackObj obj1 = DAVQL_POP(); 955 DavQLStackObj obj1 = DAVQL_POP();
940 if(obj1.type == 0 && obj2.type == 0) { 956 if(obj1.type == 0 && obj2.type == 0) {
941 DAVQL_PUSH_INT(obj1.data.integer * obj2.data.integer); 957 DAVQL_PUSH_INT(obj1.data.integer * obj2.data.integer);
942 } else { 958 } else {
945 i = count; // end loop 961 i = count; // end loop
946 } 962 }
947 break; 963 break;
948 } 964 }
949 case DAVQL_CMD_OP_BINARY_DIV: { 965 case DAVQL_CMD_OP_BINARY_DIV: {
950 printf("div\n"); 966 //printf("div\n");
951 DavQLStackObj obj2 = DAVQL_POP(); 967 DavQLStackObj obj2 = DAVQL_POP();
952 DavQLStackObj obj1 = DAVQL_POP(); 968 DavQLStackObj obj1 = DAVQL_POP();
953 if(obj1.type == 0 && obj2.type == 0) { 969 if(obj1.type == 0 && obj2.type == 0) {
954 DAVQL_PUSH_INT(obj1.data.integer / obj2.data.integer); 970 DAVQL_PUSH_INT(obj1.data.integer / obj2.data.integer);
955 } else { 971 } else {
958 i = count; // end loop 974 i = count; // end loop
959 } 975 }
960 break; 976 break;
961 } 977 }
962 case DAVQL_CMD_OP_BINARY_AND: { 978 case DAVQL_CMD_OP_BINARY_AND: {
963 printf("and\n"); 979 //printf("and\n");
964 DavQLStackObj obj2 = DAVQL_POP(); 980 DavQLStackObj obj2 = DAVQL_POP();
965 DavQLStackObj obj1 = DAVQL_POP(); 981 DavQLStackObj obj1 = DAVQL_POP();
966 if(obj1.type == 0 && obj2.type == 0) { 982 if(obj1.type == 0 && obj2.type == 0) {
967 DAVQL_PUSH_INT(obj1.data.integer & obj2.data.integer); 983 DAVQL_PUSH_INT(obj1.data.integer & obj2.data.integer);
968 } else { 984 } else {
971 i = count; // end loop 987 i = count; // end loop
972 } 988 }
973 break; 989 break;
974 } 990 }
975 case DAVQL_CMD_OP_BINARY_OR: { 991 case DAVQL_CMD_OP_BINARY_OR: {
976 printf("or\n"); 992 //printf("or\n");
977 DavQLStackObj obj2 = DAVQL_POP(); 993 DavQLStackObj obj2 = DAVQL_POP();
978 DavQLStackObj obj1 = DAVQL_POP(); 994 DavQLStackObj obj1 = DAVQL_POP();
979 if(obj1.type == 0 && obj2.type == 0) { 995 if(obj1.type == 0 && obj2.type == 0) {
980 DAVQL_PUSH_INT(obj1.data.integer | obj2.data.integer); 996 DAVQL_PUSH_INT(obj1.data.integer | obj2.data.integer);
981 } else { 997 } else {
984 i = count; // end loop 1000 i = count; // end loop
985 } 1001 }
986 break; 1002 break;
987 } 1003 }
988 case DAVQL_CMD_OP_BINARY_XOR: { 1004 case DAVQL_CMD_OP_BINARY_XOR: {
989 printf("xor\n"); 1005 //printf("xor\n");
990 DavQLStackObj obj2 = DAVQL_POP(); 1006 DavQLStackObj obj2 = DAVQL_POP();
991 DavQLStackObj obj1 = DAVQL_POP(); 1007 DavQLStackObj obj1 = DAVQL_POP();
992 if(obj1.type == 0 && obj2.type == 0) { 1008 if(obj1.type == 0 && obj2.type == 0) {
993 DAVQL_PUSH_INT(obj1.data.integer ^ obj2.data.integer); 1009 DAVQL_PUSH_INT(obj1.data.integer ^ obj2.data.integer);
994 } else { 1010 } else {
997 i = count; // end loop 1013 i = count; // end loop
998 } 1014 }
999 break; 1015 break;
1000 } 1016 }
1001 case DAVQL_CMD_OP_LOGICAL_NOT: { 1017 case DAVQL_CMD_OP_LOGICAL_NOT: {
1002 printf("not\n"); 1018 //printf("not\n");
1003 break; 1019 break;
1004 } 1020 }
1005 case DAVQL_CMD_OP_LOGICAL_AND: { 1021 case DAVQL_CMD_OP_LOGICAL_AND: {
1006 printf("land\n"); 1022 //printf("land\n");
1007 DavQLStackObj obj2 = DAVQL_POP(); 1023 DavQLStackObj obj2 = DAVQL_POP();
1008 DavQLStackObj obj1 = DAVQL_POP(); 1024 DavQLStackObj obj1 = DAVQL_POP();
1009 int v1 = obj1.type == 0 ? (int)obj1.data.integer : (obj1.data.string ? 1 : 0); 1025 int v1 = obj1.type == 0 ? (int)obj1.data.integer : (obj1.data.string ? 1 : 0);
1010 int v2 = obj2.type == 0 ? (int)obj2.data.integer : (obj2.data.string ? 1 : 0); 1026 int v2 = obj2.type == 0 ? (int)obj2.data.integer : (obj2.data.string ? 1 : 0);
1011 DAVQL_PUSH_INT(v1 && v2); 1027 DAVQL_PUSH_INT(v1 && v2);
1012 break; 1028 break;
1013 } 1029 }
1014 case DAVQL_CMD_OP_LOGICAL_OR_L: { 1030 case DAVQL_CMD_OP_LOGICAL_OR_L: {
1015 printf("or_l %d\n", cmd.data.integer); 1031 //printf("or_l %d\n", cmd.data.integer);
1016 DavQLStackObj obj1 = DAVQL_POP(); 1032 DavQLStackObj obj1 = DAVQL_POP();
1017 if((obj1.type == 0 && obj1.data.integer) || (obj1.type == 1 && obj1.data.string)) { 1033 if((obj1.type == 0 && obj1.data.integer) || (obj1.type == 1 && obj1.data.string)) {
1018 DAVQL_PUSH_INT(1); 1034 DAVQL_PUSH_INT(1);
1019 i += cmd.data.integer; // jump, skip right subtree of 'or' 1035 i += cmd.data.integer; // jump, skip right subtree of 'or'
1020 } 1036 }
1021 break; 1037 break;
1022 } 1038 }
1023 case DAVQL_CMD_OP_LOGICAL_OR: { 1039 case DAVQL_CMD_OP_LOGICAL_OR: {
1024 printf("or\n"); 1040 //printf("or\n");
1025 DavQLStackObj obj2 = DAVQL_POP(); 1041 DavQLStackObj obj2 = DAVQL_POP();
1026 DavQLStackObj obj1 = DAVQL_POP(); 1042 DavQLStackObj obj1 = DAVQL_POP();
1027 int v1 = obj1.type == 0 ? (int)obj1.data.integer : (obj1.data.string ? 1 : 0); 1043 int v1 = obj1.type == 0 ? (int)obj1.data.integer : (obj1.data.string ? 1 : 0);
1028 int v2 = obj2.type == 0 ? (int)obj2.data.integer : (obj2.data.string ? 1 : 0); 1044 int v2 = obj2.type == 0 ? (int)obj2.data.integer : (obj2.data.string ? 1 : 0);
1029 DAVQL_PUSH_INT(v1 || v2); 1045 DAVQL_PUSH_INT(v1 || v2);
1030 break; 1046 break;
1031 } 1047 }
1032 case DAVQL_CMD_OP_LOGICAL_XOR: { 1048 case DAVQL_CMD_OP_LOGICAL_XOR: {
1033 printf("lxor\n"); 1049 //printf("lxor\n");
1034 DavQLStackObj obj2 = DAVQL_POP(); 1050 DavQLStackObj obj2 = DAVQL_POP();
1035 DavQLStackObj obj1 = DAVQL_POP(); 1051 DavQLStackObj obj1 = DAVQL_POP();
1036 int v1 = obj1.type == 0 ? (int)obj1.data.integer : (obj1.data.string ? 1 : 0); 1052 int v1 = obj1.type == 0 ? (int)obj1.data.integer : (obj1.data.string ? 1 : 0);
1037 int v2 = obj2.type == 0 ? (int)obj2.data.integer : (obj2.data.string ? 1 : 0); 1053 int v2 = obj2.type == 0 ? (int)obj2.data.integer : (obj2.data.string ? 1 : 0);
1038 DAVQL_PUSH_INT(!v1 != !v2); 1054 DAVQL_PUSH_INT(!v1 != !v2);
1039 break; 1055 break;
1040 } 1056 }
1041 case DAVQL_CMD_OP_EQ: { 1057 case DAVQL_CMD_OP_EQ: {
1042 printf("eq\n"); 1058 //printf("eq\n");
1043 DavQLStackObj obj2 = DAVQL_POP(); 1059 DavQLStackObj obj2 = DAVQL_POP();
1044 DavQLStackObj obj1 = DAVQL_POP(); 1060 DavQLStackObj obj1 = DAVQL_POP();
1045 if(obj1.type == 0 && obj2.type == 0) { 1061 if(obj1.type == 0 && obj2.type == 0) {
1046 DAVQL_PUSH_INT(obj1.data.integer == obj2.data.integer); 1062 DAVQL_PUSH_INT(obj1.data.integer == obj2.data.integer);
1047 } else { 1063 } else {
1048 // TODO: string compare 1064 // TODO: string compare
1049 } 1065 }
1050 break; 1066 break;
1051 } 1067 }
1052 case DAVQL_CMD_OP_NEQ: { 1068 case DAVQL_CMD_OP_NEQ: {
1053 printf("neq\n"); 1069 //printf("neq\n");
1054 DavQLStackObj obj2 = DAVQL_POP(); 1070 DavQLStackObj obj2 = DAVQL_POP();
1055 DavQLStackObj obj1 = DAVQL_POP(); 1071 DavQLStackObj obj1 = DAVQL_POP();
1056 if(obj1.type == 0 && obj2.type == 0) { 1072 if(obj1.type == 0 && obj2.type == 0) {
1057 DAVQL_PUSH_INT(obj1.data.integer != obj2.data.integer); 1073 DAVQL_PUSH_INT(obj1.data.integer != obj2.data.integer);
1058 } else { 1074 } else {
1059 // TODO: string compare 1075 // TODO: string compare
1060 } 1076 }
1061 break; 1077 break;
1062 } 1078 }
1063 case DAVQL_CMD_OP_LT: { 1079 case DAVQL_CMD_OP_LT: {
1064 printf("lt\n"); 1080 //printf("lt\n");
1065 DavQLStackObj obj2 = DAVQL_POP(); 1081 DavQLStackObj obj2 = DAVQL_POP();
1066 DavQLStackObj obj1 = DAVQL_POP(); 1082 DavQLStackObj obj1 = DAVQL_POP();
1067 if(obj1.type == 0 && obj2.type == 0) { 1083 if(obj1.type == 0 && obj2.type == 0) {
1068 DAVQL_PUSH_INT(obj1.data.integer < obj2.data.integer); 1084 DAVQL_PUSH_INT(obj1.data.integer < obj2.data.integer);
1069 } else { 1085 } else {
1070 // TODO: string compare 1086 // TODO: string compare
1071 } 1087 }
1072 break; 1088 break;
1073 } 1089 }
1074 case DAVQL_CMD_OP_GT: { 1090 case DAVQL_CMD_OP_GT: {
1075 printf("gt\n"); 1091 //printf("gt\n");
1076 DavQLStackObj obj2 = DAVQL_POP(); 1092 DavQLStackObj obj2 = DAVQL_POP();
1077 DavQLStackObj obj1 = DAVQL_POP(); 1093 DavQLStackObj obj1 = DAVQL_POP();
1078 if(obj1.type == 0 && obj2.type == 0) { 1094 if(obj1.type == 0 && obj2.type == 0) {
1079 DAVQL_PUSH_INT(obj1.data.integer > obj2.data.integer); 1095 DAVQL_PUSH_INT(obj1.data.integer > obj2.data.integer);
1080 } else { 1096 } else {
1081 // TODO: string compare 1097 // TODO: string compare
1082 } 1098 }
1083 break; 1099 break;
1084 } 1100 }
1085 case DAVQL_CMD_OP_LE: { 1101 case DAVQL_CMD_OP_LE: {
1086 printf("le\n"); 1102 //printf("le\n");
1087 DavQLStackObj obj2 = DAVQL_POP(); 1103 DavQLStackObj obj2 = DAVQL_POP();
1088 DavQLStackObj obj1 = DAVQL_POP(); 1104 DavQLStackObj obj1 = DAVQL_POP();
1089 if(obj1.type == 0 && obj2.type == 0) { 1105 if(obj1.type == 0 && obj2.type == 0) {
1090 DAVQL_PUSH_INT(obj1.data.integer <= obj2.data.integer); 1106 DAVQL_PUSH_INT(obj1.data.integer <= obj2.data.integer);
1091 } else { 1107 } else {
1092 // TODO: string compare 1108 // TODO: string compare
1093 } 1109 }
1094 break; 1110 break;
1095 } 1111 }
1096 case DAVQL_CMD_OP_GE: { 1112 case DAVQL_CMD_OP_GE: {
1097 printf("ge\n"); 1113 //printf("ge\n");
1098 DavQLStackObj obj2 = DAVQL_POP(); 1114 DavQLStackObj obj2 = DAVQL_POP();
1099 DavQLStackObj obj1 = DAVQL_POP(); 1115 DavQLStackObj obj1 = DAVQL_POP();
1100 if(obj1.type == 0 && obj2.type == 0) { 1116 if(obj1.type == 0 && obj2.type == 0) {
1101 DAVQL_PUSH_INT(obj1.data.integer >= obj2.data.integer); 1117 DAVQL_PUSH_INT(obj1.data.integer >= obj2.data.integer);
1102 } else { 1118 } else {
1103 // TODO: string compare 1119 // TODO: string compare
1104 } 1120 }
1105 break; 1121 break;
1106 } 1122 }
1107 case DAVQL_CMD_OP_LIKE: { 1123 case DAVQL_CMD_OP_LIKE: {
1108 printf("like\n"); 1124 //printf("like\n");
1109 break; 1125 break;
1110 } 1126 }
1111 case DAVQL_CMD_OP_UNLIKE: { 1127 case DAVQL_CMD_OP_UNLIKE: {
1112 printf("unlike\n"); 1128 //printf("unlike\n");
1113 break; 1129 break;
1114 } 1130 }
1115 case DAVQL_CMD_CALL: { 1131 case DAVQL_CMD_CALL: {
1116 printf("call %x\n", cmd.data.func); 1132 //printf("call %x\n", cmd.data.func);
1117 break; 1133 break;
1118 } 1134 }
1119 } 1135 }
1120 } 1136 }
1121 1137

Mercurial Repository: dav

mercurial