Lines Matching refs:com
46 ComVariableSetFlag(com, atom, VARIABLE_USED)
48 ComVariableSetFlag(com, atom, VARIABLE_ARGUMENT)
75 Com_And(LispCom *com, LispBuiltin *builtin)
86 ComEval(com, CAR(args));
97 ComEval(com, CAR(args));
112 com_Bytecode(com, XBC_T);
116 Com_Block(LispCom *com, LispBuiltin *builtin)
131 CompileIniBlock(com, LispBlockTag, name);
132 ComProgn(com, body);
133 CompileFiniBlock(com);
137 com_Bytecode(com, XBC_NIL);
141 Com_C_r(LispCom *com, LispBuiltin *builtin)
160 ComEval(com, list);
162 com_Bytecode(com, *desc == 'A' ? XBC_CAR : XBC_CDR);
168 Com_Cond(LispCom *com, LispBuiltin *builtin)
186 ComEval(com, CAR(code));
193 ComProgn(com, CDR(code));
203 com_Bytecode(com, XBC_NIL);
210 Com_Cons(LispCom *com, LispBuiltin *builtin)
220 if (ComConstantp(com, car) && ComConstantp(com, cdr))
221 com_BytecodeCons(com, XBC_CCONS, car, cdr);
223 ++com->stack.cpstack;
224 if (com->stack.pstack < com->stack.cpstack)
225 com->stack.pstack = com->stack.cpstack;
226 ComEval(com, car);
227 com_Bytecode(com, XBC_CSTAR);
228 ComEval(com, cdr);
229 com_Bytecode(com, XBC_CFINI);
230 --com->stack.cpstack;
235 Com_Consp(LispCom *com, LispBuiltin *builtin)
240 ComPredicate(com, builtin, XBP_CONSP);
244 Com_Dolist(LispCom *com, LispBuiltin *builtin)
306 CompileIniBlock(com, LispBlockTag, NIL);
309 ComPush(com, UNBOUND, list, 1, 0, 0);
311 ComPush(com, symbol, NIL, 0, 0, 0);
313 CompileStackEnter(com, 2, 0);
315 com_Bind(com, 2);
316 com->block->bind += 2;
324 CompileIniBlock(com, LispBlockBody, NIL);
327 ComLabel(com, DOT);
330 com_BytecodeShort(com, XBC_LOAD, unbound);
332 com_BytecodeChar(com, XBC_PRED, XBP_CONSP);
338 com_BytecodeShort(com, XBC_LOAD, unbound);
340 com_Bytecode(com, XBC_CAR);
342 com_BytecodeShort(com, XBC_SET, item);
344 ComProgn(com, body);
347 com_BytecodeShort(com, XBC_LOAD, unbound);
349 com_Bytecode(com, XBC_CDR);
351 com_BytecodeShort(com, XBC_SET, unbound);
363 CompileFiniBlock(com);
368 com_BytecodeShort(com, XBC_SET, item);
371 ComEval(com, result);
376 com->block->bind -= 2;
377 com_Unbind(com, 2);
379 CompileStackLeave(com, 2, 0);
382 CompileFiniBlock(com);
387 Com_Eq(LispCom *com, LispBuiltin *builtin)
402 CompileStackEnter(com, 1, 1);
404 ComEval(com, left);
405 com_Bytecode(com, XBC_PUSH);
407 ComEval(com, right);
422 com_Bytecode(com, code);
424 CompileStackLeave(com, 1, 1);
428 Com_Go(LispCom *com, LispBuiltin *builtin)
440 block = com->block;
455 com_Unbind(com, bind);
461 Com_If(LispCom *com, LispBuiltin *builtin)
474 ComEval(com, test);
481 ComEval(com, then);
490 ComEval(com, oelse);
500 Com_Last(LispCom *com, LispBuiltin *builtin)
510 ComEval(com, list);
511 CompileStackEnter(com, 1, 1);
512 com_Bytecode(com, XBC_PUSH);
515 ComEval(com, count);
516 CompileStackLeave(com, 1, 1);
517 com_Bytecode(com, XBC_LAST);
521 Com_Length(LispCom *com, LispBuiltin *builtin)
530 ComEval(com, sequence);
531 com_Bytecode(com, XBC_LENGTH);
535 Com_Let(LispCom *com, LispBuiltin *builtin)
550 ComProgn(com, body);
580 ComPush(com, symbol, value, 1, 0, 0);
584 CompileStackEnter(com, count, 0);
586 com_Bind(com, count);
587 com->block->bind += count;
590 ComProgn(com, body);
594 com->block->bind -= count;
595 com_Unbind(com, count);
597 CompileStackLeave(com, count, 0);
601 Com_Letx(LispCom *com, LispBuiltin *builtin)
616 ComProgn(com, body);
646 ComPush(com, symbol, value, 1, 0, 0);
648 com_Bind(com, 1);
651 ++com->block->bind;
655 CompileStackEnter(com, count, 0);
656 ComProgn(com, body);
657 com_Unbind(com, count);
658 com->block->bind -= count;
661 CompileStackLeave(com, count, 0);
665 Com_Listp(LispCom *com, LispBuiltin *builtin)
670 ComPredicate(com, builtin, XBP_LISTP);
674 Com_Loop(LispCom *com, LispBuiltin *builtin)
685 CompileIniBlock(com, LispBlockTag, NIL);
693 ComProgn(com, body);
696 com_Bytecode(com, XBC_NIL);
704 CompileFiniBlock(com);
708 Com_Nthcdr(LispCom *com, LispBuiltin *builtin)
718 ComEval(com, oindex);
719 CompileStackEnter(com, 1, 1);
720 com_Bytecode(com, XBC_PUSH);
721 ComEval(com, list);
722 CompileStackLeave(com, 1, 1);
723 com_Bytecode(com, XBC_NTHCDR);
727 Com_Null(LispCom *com, LispBuiltin *builtin)
737 com_Bytecode(com, XBC_T);
738 else if (ComConstantp(com, list))
739 com_Bytecode(com, XBC_NIL);
741 ComEval(com, list);
742 com_Bytecode(com, XBC_INV);
747 Com_Numberp(LispCom *com, LispBuiltin *builtin)
752 ComPredicate(com, builtin, XBP_NUMBERP);
756 Com_Or(LispCom *com, LispBuiltin *builtin)
767 ComEval(com, CAR(args));
778 ComEval(com, CAR(args));
792 com_Bytecode(com, XBC_NIL);
796 Com_Progn(LispCom *com, LispBuiltin *builtin)
805 ComProgn(com, body);
809 Com_Return(LispCom *com, LispBuiltin *builtin)
814 ComReturnFrom(com, builtin, 0);
818 Com_ReturnFrom(LispCom *com, LispBuiltin *builtin)
823 ComReturnFrom(com, builtin, 1);
827 Com_Rplac_(LispCom *com, LispBuiltin *builtin)
837 CompileStackEnter(com, 1, 1);
838 ComEval(com, place);
839 com_Bytecode(com, XBC_PUSH);
840 ComEval(com, value);
841 com_Bytecode(com, STRFUN(builtin)[5] == 'A' ? XBC_RPLACA : XBC_RPLACD);
842 CompileStackLeave(com, 1, 1);
846 Com_Setq(LispCom *com, LispBuiltin *builtin)
865 ComEval(com, value);
866 offset = ComGetVariable(com, symbol);
868 com_Set(com, offset);
870 com_SetSym(com, symbol->data.atom);
875 Com_Tagbody(LispCom *com, LispBuiltin *builtin)
885 CompileIniBlock(com, LispBlockBody, NIL);
886 ComProgn(com, body);
888 com_Bytecode(com, XBC_NIL);
889 CompileFiniBlock(com);
893 com_Bytecode(com, XBC_NIL);
897 Com_Unless(LispCom *com, LispBuiltin *builtin)
909 ComEval(com, test);
914 ComProgn(com, body);
922 Com_Until(LispCom *com, LispBuiltin *builtin)
938 ComEval(com, test);
943 ComProgn(com, body);
957 Com_When(LispCom *com, LispBuiltin *builtin)
969 ComEval(com, test);
974 ComProgn(com, body);
982 Com_While(LispCom *com, LispBuiltin *builtin)
998 ComEval(com, test);
1003 ComProgn(com, body);
1021 ComPredicate(LispCom *com, LispBuiltin *builtin, LispBytePredicate predicate)
1027 if (ComConstantp(com, object)) {
1030 com_Bytecode(com, CONSP(object) ? XBC_T : XBC_NIL);
1033 com_Bytecode(com, CONSP(object) || object == NIL ?
1037 com_Bytecode(com, NUMBERP(object) ? XBC_T : XBC_NIL);
1042 ComEval(com, object);
1043 com_BytecodeChar(com, XBC_PRED, predicate);
1052 ComReturnFrom(LispCom *com, LispBuiltin *builtin, int from)
1057 CodeBlock *block = com->block;
1086 ComEval(com, result);
1089 com_Unbind(com, bind);
1099 ComConstantp(LispCom *com, LispObj *object)
1174 ComAddVariable(LispCom *com, LispObj *symbol, LispObj *value)
1178 if (atom && atom->key && !com->macro) {
1179 int i, length = com->block->variables.length;
1181 i = BuildTablePointer(atom, (void***)&com->block->variables.symbols,
1182 &com->block->variables.length);
1184 if (com->block->variables.length != length) {
1185 com->block->variables.flags =
1186 LispRealloc(com->block->variables.flags,
1187 com->block->variables.length * sizeof(int));
1191 memmove(com->block->variables.flags + i + 1,
1192 com->block->variables.flags + i,
1195 com->block->variables.flags[i] = 0;
1203 ComGetVariable(LispCom *com, LispObj *symbol)
1224 if (offset <= i && offset >= com->lex && lisp__data.env.names[offset] == id) {
1231 for (; i >= com->lex; i--)
1239 ++com->warnings;
1249 ComVariableSetFlag(LispCom *com, LispAtom *atom, int flag)
1252 CodeBlock *block = com->block;
1274 ComLabel(LispCom *com, LispObj *label)
1279 for (i = 0; i < com->block->tagbody.length; i++)
1280 if (label == com->block->tagbody.labels[i])
1284 if (com->block->tagbody.length >= com->block->tagbody.space) {
1285 com->block->tagbody.labels =
1286 LispRealloc(com->block->tagbody.labels,
1287 sizeof(LispObj*) * (com->block->tagbody.space + 8));
1290 com->block->tagbody.codes =
1291 LispRealloc(com->block->tagbody.codes,
1292 sizeof(CodeTree*) * (com->block->tagbody.space + 8));
1293 com->block->tagbody.space += 8;
1296 com->block->tagbody.labels[com->block->tagbody.length++] = label;
1302 ComPush(LispCom *com, LispObj *symbol, LispObj *value,
1311 ComAddVariable(com, symbol, value);
1315 /* If <com->macro> is set, it is expanding a macro, just add the local
1318 else if (com->macro) {
1319 ComAddVariable(com, symbol, value);
1325 else if (eval && !ComConstantp(com, value)) {
1328 int offset = ComGetVariable(com, value);
1333 com_LoadPush(com, offset);
1335 com_LoadLet(com, offset, symbol->data.atom);
1342 com_LoadConPush(com, value);
1344 com_LoadConLet(com, value, symbol->data.atom);
1349 com_LoadSymPush(com, value->data.atom);
1351 com_LoadSymLet(com, value->data.atom,
1358 ComEval(com, value);
1360 com_Bytecode(com, XBC_PUSH);
1362 com_Let(com, symbol->data.atom);
1371 ComAddVariable(com, symbol, value);
1377 com_LoadConPush(com, value);
1382 com_LoadConLet(com, value, symbol->data.atom);
1384 ComAddVariable(com, symbol, value);
1393 ComCall(LispCom *com, LispArgList *alist,
1436 ComPush(com, symbols[i], CAR(values), eval, builtin, compile);
1437 if (!builtin && !com->macro)
1465 ComPush(com, symbols[i], CAR(values), eval, builtin, compile);
1466 if (!builtin && !com->macro)
1469 ComPush(com, sforms[i], T, 0, builtin, compile);
1470 if (!builtin && !com->macro)
1476 int lex = com->lex;
1479 com->lex = base;
1482 ComPush(com, symbols[i], defaults[i], 1, 0, compile);
1483 if (!com->macro)
1486 com->lex = lex;
1489 ComPush(com, symbols[i], defaults[i], eval, 1, compile);
1491 ComPush(com, sforms[i], NIL, 0, builtin, compile);
1492 if (!builtin && !com->macro)
1593 ComPush(com, symbols[i], val, eval, builtin, compile);
1595 ComPush(com, sforms[i], T, 0, builtin, compile);
1600 int lex = com->lex;
1603 com->lex = base;
1605 ComPush(com, symbols[i], val, eval, 0, compile);
1607 com->lex = lex;
1610 ComPush(com, symbols[i], val, eval, builtin, compile);
1612 ComPush(com, sforms[i], NIL, 0, builtin, compile);
1614 if (!builtin && !com->macro) {
1633 ComPush(com, alist->rest, values, eval, builtin, compile);
1644 if (!ComConstantp(com, car))
1661 ComPush(com, alist->rest, values, 0, builtin, compile);
1664 CompileStackEnter(com, count - 1, 1);
1667 ComEval(com, CAR(values));
1669 com_Bytecode(com, XBC_PUSH);
1671 CompileStackLeave(com, count - 1, 1);
1673 ComEval(com, CAR(values));
1675 com_Bytecode(com, (LispByteOpcode)(XBC_BCONS + (count - 1)));
1682 ComEval(com, CAR(values));
1684 com->stack.cpstack += 2;
1685 if (com->stack.pstack < com->stack.cpstack)
1686 com->stack.pstack = com->stack.cpstack;
1688 com_Bytecode(com, XBC_LSTAR);
1692 ComEval(com, CAR(values));
1695 com_Bytecode(com, XBC_LCONS);
1699 com_Bytecode(com, XBC_LFINI);
1703 com_Bytecode(com, XBC_PUSH);
1705 com_Let(com, alist->rest->data.atom);
1708 ComAddVariable(com, alist->rest, values);
1710 com->stack.cpstack -= 2;
1713 if (!builtin && !com->macro)
1726 int lex = com->lex;
1728 com->lex = base;
1731 ComPush(com, symbols[i], defaults[i], 1, 0, 0);
1732 if (!com->macro)
1736 com->lex = lex;
1740 ComPush(com, symbols[i], defaults[i], eval, builtin, compile);
1741 if (!builtin && !com->macro)
1760 ComFuncall(LispCom *com, LispObj *function, LispObj *arguments, int eval)
1784 if (com->macro || compile || builtin->type == LispMacro)
1787 if (!com->macro && builtin->type == LispMacro) {
1799 if (!compile && !com->macro)
1800 CompileStackEnter(com, alist->num_arguments, 1);
1803 base = ComCall(com, alist, function, arguments,
1808 builtin->compile(com, builtin);
1812 com_Call(com, alist->num_arguments, builtin);
1813 CompileStackLeave(com, alist->num_arguments, 1);
1826 ComMacroCall(com, alist, function, lambda, arguments);
1829 if (com->toplevel->type == LispBlockClosure &&
1830 com->toplevel->tag == function)
1831 ComRecursiveCall(com, alist, function, arguments);
1834 ComInlineCall(com, alist, function, arguments,
1837 com_Funcall(com, function, arguments);
1851 ComEval(com, CAR(arguments));
1853 com_Structp(com, definition);
1855 com_Struct(com,
1860 CompileStackEnter(com, alist->num_arguments, 0);
1863 base = ComCall(com, alist, function, arguments, 1, 0, 0);
1864 com_Bytecall(com, alist->num_arguments,
1866 CompileStackLeave(com, alist->num_arguments, 0);
1872 ++com->warnings;
1874 com_Funcall(com, function, arguments);
1881 ComInlineCall(com, alist, NIL, arguments, lambda->data.lambda.code);
1893 ComInlineCall(com, alist, NIL, arguments, lambda->data.lambda.code);
1911 ComProgn(LispCom *com, LispObj *code)
1915 ComEval(com, CAR(code));
1919 com_Bytecode(com, XBC_NIL);
1924 ComEval(LispCom *com, LispObj *object)
1932 ComLabel(com, object);
1934 offset = ComGetVariable(com, object);
1937 com_Load(com, offset);
1939 com_LoadCon(com, object);
1942 com_LoadCon(com, LispGetVar(object));
1945 com_LoadSym(com, object->data.atom);
1951 form = com->form;
1952 com->form = object;
1953 ComFuncall(com, CAR(object), CDR(object), 1);
1954 com->form = form;
1958 com_LoadCon(com, object->data.quote);
1962 /* Macro expansion is stored in the current value of com->form */
1963 ComMacroBackquote(com, object);
1978 RPLACD(com->plist, CONS(CAR(com->plist), CDR(com->plist)));
1979 RPLACA(com->plist, object);
1983 com_LoadCon(com, object);
1988 ComLabel(com, object);
1995 com_LoadCon(com, object);
2004 ComRecursiveCall(LispCom *com, LispArgList *alist,
2015 base = ComCall(com, alist, name, arguments, 1, 0, 0);
2018 CompileStackEnter(com, alist->num_arguments, 0);
2022 com_Bind(com, alist->num_arguments);
2023 com->block->bind += alist->num_arguments;
2026 com_BytecodeChar(com, XBC_LETREC, alist->num_arguments);
2030 com_Unbind(com, alist->num_arguments);
2031 com->block->bind -= alist->num_arguments;
2035 CompileStackLeave(com, alist->num_arguments, 0);
2044 ComInlineCall(LispCom *com, LispArgList *alist,
2054 CompileIniBlock(com, LispBlockClosure, name);
2057 base = ComCall(com, alist, name, arguments, 1, 0, 0);
2060 CompileStackEnter(com, alist->num_arguments, 0);
2063 com_Bind(com, alist->num_arguments);
2064 com->block->bind += alist->num_arguments;
2067 ComProgn(com, lambda);
2070 com_Unbind(com, alist->num_arguments);
2071 com->block->bind -= alist->num_arguments;
2074 CompileStackLeave(com, alist->num_arguments, 0);
2077 CompileFiniBlock(com);
2089 ComMacroExpandBackquote(LispCom *com, LispObj *object)
2095 ComMacroExpandFuncall(LispCom *com, LispObj *function, LispObj *arguments)
2101 ComMacroExpandEval(LispCom *com, LispObj *object)
2116 result = ComMacroExpandFuncall(com, CAR(object), CDR(object));
2124 result = ComMacroExpandBackquote(com, object);
2143 ComMacroExpand(LispCom *com, LispObj *lambda)
2165 result = ComMacroExpandEval(com, CAR(lambda));
2168 result = ComMacroExpandBackquote(com, lambda);
2193 ComMacroCall(LispCom *com, LispArgList *alist,
2199 ++com->macro;
2200 base = ComCall(com, alist, name, arguments, 0, 0, 0);
2202 body = ComMacroExpand(com, body);
2203 --com->macro;
2207 CAR(com->form) = body;
2208 ComEval(com, body);
2212 ComMacroBackquote(LispCom *com, LispObj *lambda)
2216 ++com->macro;
2217 body = ComMacroExpand(com, lambda);
2218 --com->macro;
2221 CAR(com->form) = body;
2223 com_LoadCon(com, body);