Subversion Repositories Kolibri OS

Rev

Rev 6822 | Rev 6857 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1.  
  2. /// ===========================================================
  3.  
  4. void command_history_add()
  5. {
  6.  
  7. int i;
  8.  
  9. if ('\0' == CMD[0]) return;
  10.  
  11. CMD_NUM = -1;
  12.  
  13. for (i = 0; i < CMD_HISTORY_NUM_REAL; i++)
  14.         if ( 0 == strcmp( CMD_HISTORY[i], CMD ) )
  15.                 return;
  16.  
  17. for (i = CMD_HISTORY_NUM_REAL; i > 0 ; i--)
  18.         strcpy(CMD_HISTORY[i], CMD_HISTORY[i-1]);
  19.  
  20. strcpy(CMD_HISTORY[0], CMD);
  21.  
  22. if (CMD_HISTORY_NUM_REAL < CMD_HISTORY_NUM-1)
  23.         CMD_HISTORY_NUM_REAL++;
  24.  
  25. }
  26.  
  27.  
  28.  
  29. /// ===========================================================
  30.  
  31. void command_get()
  32. {
  33. unsigned key;
  34.  
  35. unsigned i;
  36. unsigned cmdLen = 0;
  37. unsigned cmdPos = 0;
  38. CMD[0] = '\0';
  39.  
  40. int clipNum; // number of clipboard slots
  41. char* clipBuf; // clipboard buffer
  42. char clipCopy[255+12];
  43.  
  44. for (;;)
  45.         {
  46.         key = getch();
  47.         if ( 0 != (key & 0xff) )
  48.                 {
  49.                 key &= 0xff;
  50.                 switch (key)
  51.                         {
  52.                         case 27: // ESC
  53.                                 for (i = cmdPos; i < cmdLen; i++)
  54.                                         printf(" ");
  55.                                 for (i = cmdLen; i > 0; i--)
  56.                                         printf("%c %c", 8, 8);
  57.                                 cmdLen = 0;
  58.                                 cmdPos = 0;
  59.                                 CMD[0] = '\0';
  60.                                 break;
  61.  
  62.                         case 13: // ENTER
  63.                                 printf("\n\r");
  64.                                 command_history_add();
  65.                                 return;
  66.  
  67.                         case 8: // BACKSPACE
  68.                                 if (cmdPos > 0)
  69.                                         {
  70.                                         for (i = cmdPos-1; i < cmdLen; i++)
  71.                                                                                 CMD[i] = CMD[i+1];
  72.                                         for (i = 0; i < cmdLen-cmdPos; i++)
  73.                                                 printf (" ");
  74.  
  75.                                         for (i = 0; i < cmdLen; i++)
  76.                                                 printf ("%c %c", 8, 8);
  77.  
  78.                                         printf("%s", CMD);
  79.  
  80.                                         for (i = 0; i < cmdLen-cmdPos; i++)
  81.                                                 printf("%c", 8);
  82.  
  83.                                         cmdPos--;
  84.                                         cmdLen--;
  85.                                         }
  86.                                 break;
  87.  
  88.  
  89.                         case 9: // TAB
  90.                                 break;
  91.                                
  92.                                
  93.                         case 22: // Ctrl+V
  94.                                 clipNum = kol_clip_num();
  95.                                 if (clipNum > 0)
  96.                                         {
  97.                                         clipBuf = kol_clip_get(clipNum-1);
  98. //                                      printf("Length: %d, Type: %d, Encoding: %d\n", (int) *clipBuf, (int)*(clipBuf+4), (int)*(clipBuf+8));
  99.                                         if ( (int) *clipBuf > 0 ) // is clipboard empty?
  100.                                                 {
  101.                                                 if ((int)*(clipBuf+4)==0) // text?
  102.                                                         {
  103.                                                         if ((int)*(clipBuf+8)==1) // 866 encoding?
  104.                                                                 {
  105.                                                                 for (i = cmdPos; i < cmdLen; i++)
  106.                                                                         printf(" ");
  107.                                                                 for (i = cmdLen; i > 0; i--)
  108.                                                                         printf("%c %c", 8, 8);
  109.                                                                 cmdLen = 0;
  110.                                                                 cmdPos = 0;
  111.                                                                 CMD[0] = '\0';
  112.  
  113.                                                                 // strcpy_n
  114.                                                                 for (i = 0; i < 255; i++)
  115.                                                                         {
  116.                                                                         CMD[i]=*(clipBuf+12+i);
  117.                                                                         if (CMD[i]=='\0')
  118.                                                                                 break;
  119.                                                                         }
  120.                                                                
  121.                                                                 cmdPos = cmdLen = strlen(CMD);
  122. /*                                                             
  123.                                                                 printf("Length: %d\n", cmdLen);
  124.                                                                 for (i = 0; i < cmdLen; i++)
  125.                                                                         printf("%d ", CMD[i]);
  126. */
  127.                                                                 printf("%s", CMD);
  128.  
  129.                                                                 }
  130.                                                         }
  131.                                                 }
  132.                                         }
  133.                                 break;
  134.  
  135.                                
  136.                         case 3: // Ctrl+C
  137.                                 if ( cmdLen > 0 )
  138.                                         {
  139.                                        
  140.                                         *clipCopy = 12 + cmdLen;
  141.                                         *(clipCopy+4)=0;
  142.                                         *(clipCopy+8)=1;
  143.                                        
  144.                                         for (i = 0; i <= cmdLen; i++)
  145.                                                 *(clipCopy+12+i) = CMD[i];
  146.                                                
  147.                                         kol_clip_set(12+cmdLen, clipCopy);
  148.                                        
  149.                                         }
  150.                                 break;
  151.                                
  152.                                
  153.                         default:
  154.                                 if (cmdLen < 255)
  155.                                         {
  156.                                         if ( kol_key_control() & 0x40 ) // ¥á«¨ ¢ª«îçñ­ CapsLock
  157.                                                 if ( (kol_key_control() & 1) || (kol_key_control() & 2)) // ¥á«¨ ­ ¦ âë è¨äâë
  158.                                                         key = tolower(key);
  159.                                                 else
  160.                                                         key = toupper(key);
  161.  
  162.                                         for (i = cmdLen+1; i > cmdPos; i--)
  163.                                                 CMD[i] = CMD[i-1];
  164.  
  165.                                         CMD[cmdPos] = key;
  166.  
  167.                                         for (i = cmdPos; i > 0; i--)
  168.                                                 printf("%c %c", 8, 8);
  169.  
  170.                                         printf("%s", CMD);
  171.  
  172.                                         for (i = 0; i < cmdLen-cmdPos; i++)
  173.                                                 printf("%c", 8);
  174.  
  175.                                         cmdPos++;
  176.                                         cmdLen++;
  177.                                         }
  178.                                 break;
  179.  
  180.                         }
  181.                 }
  182.         else
  183.                 {
  184.                 key = (key>>8)&0xff;
  185.                 switch (key)
  186.                         {
  187.                         case 83: // Del
  188.                                 if (cmdPos < cmdLen)
  189.                                         {
  190.                                                 for (i = cmdPos; i < cmdLen; i++)
  191.                                                         CMD[i] = CMD[i+1];
  192.  
  193.                                                 for (i = 0; i < cmdLen-cmdPos; i++)
  194.                                                         printf(" ");
  195.  
  196.                                                 for (i = 0; i < cmdLen-cmdPos; i++)
  197.                                                         printf("%c", 8);
  198.  
  199.                                                 for (i = cmdPos; i < cmdLen; i++)
  200.                                                         printf("%c", CMD[i]);
  201.  
  202.                                                 for (i = 0; i < cmdLen-cmdPos; i++)
  203.                                                         printf("%c", 8);
  204.  
  205.                                                 cmdLen--;
  206.                                         }
  207.                                 break;
  208.  
  209.                         case 75: // Left
  210.                                 if (cmdPos > 0)
  211.                                         {
  212.                                                 printf("%c", 8);
  213.                                                 cmdPos--;
  214.                                         }
  215.                                 break;
  216.  
  217.  
  218.                         case 77: // Right
  219.                                 if (cmdPos < cmdLen)
  220.                                         {
  221.                                                 printf("%c", CMD[cmdPos]);
  222.                                                 cmdPos++;
  223.                                         }
  224.                                 break;
  225.  
  226.  
  227.                         case 72: // Up
  228.                                 if (CMD_HISTORY_NUM_REAL > 0 && CMD_NUM >= -1)
  229.                                         {
  230.  
  231.                                         for (i = cmdPos; i < cmdLen; i++)
  232.                                                 printf(" ");
  233.  
  234.                                         for (i = cmdLen; i > 0; i--)
  235.                                                 printf("%c %c", 8, 8);
  236.  
  237.                                         if (CMD_NUM < CMD_HISTORY_NUM_REAL-1)
  238.                                                 CMD_NUM++;
  239. /*                                      else
  240.                                                 CMD_NUM = 0;
  241. */
  242.                                         printf("%s", CMD_HISTORY[CMD_NUM]);
  243.                                         strcpy(CMD, CMD_HISTORY[CMD_NUM]);
  244.                                         cmdLen = strlen(CMD);
  245.                                         cmdPos = strlen(CMD);
  246.  
  247.                                         }
  248.                        
  249.                                 break;
  250.  
  251.  
  252.                         case 80: // Down
  253.                                 if (CMD_HISTORY_NUM_REAL > 0 && CMD_NUM >= 0)
  254.                                         {
  255.  
  256.                                         for (i = cmdPos; i < cmdLen; i++)
  257.                                                 printf(" ");
  258.  
  259.                                         for (i = cmdLen; i > 0; i--)
  260.                                                 printf("%c %c", 8, 8);
  261.  
  262.                                         if (CMD_NUM > 0)
  263.                                                 CMD_NUM--;
  264. /*                                      else
  265.                                                 CMD_NUM = CMD_HISTORY_NUM_REAL-1;
  266. */
  267.                                         printf("%s", CMD_HISTORY[CMD_NUM]);
  268.                                         strcpy(CMD, CMD_HISTORY[CMD_NUM]);
  269.                                         cmdLen = strlen(CMD);
  270.                                         cmdPos = strlen(CMD);
  271.  
  272.                                         }
  273.                                 break;
  274.  
  275.  
  276.                         case 0: // console window closed
  277.                                 cmd_exit(NULL);
  278.  
  279.                         }
  280.  
  281.                 }
  282.         }
  283.  
  284. }
  285.  
  286. /// ===========================================================
  287.  
  288. int command_get_cmd(char cmd[])
  289. {
  290. unsigned i, len;
  291. int quote = 0;
  292.  
  293. if (CMD[0]=='"')
  294.    quote = 1;
  295.  
  296. if (quote == 0)
  297.         {
  298.         for (i=0;;i++)
  299.                 {
  300.                 cmd[i] = CMD[i];
  301.                 if (0 == cmd[i])
  302.                         return i;
  303.                 if ( iswhite(cmd[i]) )
  304.                         {
  305.                         cmd[i] = '\0';
  306.                         break;
  307.                         }
  308.                 }
  309.         return i+1;
  310.         }
  311. else
  312.         {
  313.         len = 0;
  314.         for (i=1;;i++)
  315.                 {
  316.                 cmd[len] = CMD[i];
  317.                 if (0 == cmd[len])
  318.                         {
  319.                         i--;
  320.                         break;
  321.                         }
  322.                 if ( cmd[len] == '"' )
  323.                         {
  324.                         cmd[len] = '\0';
  325.                         break;
  326.                         }
  327.                 len++;
  328.                 }
  329.         trim(cmd);
  330.         return i+1;
  331.         }
  332. }
  333.  
  334. /// ===========================================================
  335.  
  336. typedef int (*handler1_t)(char* arg);
  337.  
  338. /// ===========================================================
  339.  
  340. void command_execute()
  341. {
  342. char cmd[256];
  343. char args[256];
  344. unsigned arg;
  345. int i;
  346. int result;
  347.  
  348. trim(CMD);
  349. arg = command_get_cmd(cmd);
  350.  
  351. if ( !strlen(cmd) )
  352.         return;
  353.  
  354. strcpy(args, CMD+arg);
  355. trim(args);
  356.  
  357. for (i = 0; i < NUM_OF_CMD; i++)
  358.         {
  359.         if (!strcmp(cmd, COMMANDS[i].name))
  360.                 {
  361.                 result = ((handler1_t)COMMANDS[i].handler)(args);
  362.                 if (result != TRUE)
  363.                         {
  364.                         #if LANG_ENG
  365.                                 printf("  Error!\n\r");
  366.                         #elif LANG_RUS
  367.                                 printf("  Žè¨¡ª !\n\r");
  368.                         #endif
  369.                         }
  370.                 return;
  371.                 }
  372.         }
  373.  
  374.  
  375. if ( -1 != alias_search(CMD) )
  376.         {
  377.         strcpy(CMD, ALIASES+64*1024+256*alias_search(CMD));
  378.         command_execute();
  379.         return;
  380.         }
  381.  
  382. executable_run(cmd, args);
  383.  
  384. }
  385.  
  386. /// ===========================================================
  387.  
  388.