Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1.  
  2. /// ===========================================================
  3.  
  4. void command_clear()
  5. {
  6. for (;CMD_POS;CMD_POS--)
  7.         printf("%c %c", 8, 8);
  8. CMD[0]='\0';
  9. }
  10.  
  11. /// ===========================================================
  12.  
  13. void command_history_add(char command[])
  14. {
  15.  
  16. if (    (0 != strcmp( CMD_HISTORY[0], CMD)) &&
  17.         (0 != strcmp( CMD_HISTORY[1], CMD)) &&
  18.         (0 != strcmp( CMD_HISTORY[2], CMD)) &&
  19.         (0 != strcmp( CMD_HISTORY[3], CMD)) &&
  20.         (0 != strcmp( CMD_HISTORY[4], CMD)) )
  21.  
  22.         {
  23.         strcpy(CMD_HISTORY[4], CMD_HISTORY[3]);
  24.         strcpy(CMD_HISTORY[3], CMD_HISTORY[2]);
  25.         strcpy(CMD_HISTORY[2], CMD_HISTORY[1]);
  26.         strcpy(CMD_HISTORY[1], CMD_HISTORY[0]);
  27.  
  28.         strcpy(CMD_HISTORY[0], CMD);
  29.         }
  30.  
  31. }
  32.  
  33. /// ===========================================================
  34.  
  35. void command_get()
  36. {
  37. unsigned key;
  38. //unsigned pos = 0;
  39. int hist;
  40.  
  41. CMD_POS = 0;
  42. CMD_NUM = 0;
  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.                                 command_clear();
  54.                                 break;
  55.  
  56.                         case 13: // ENTER
  57.                                 CMD[CMD_POS] = '\0';
  58.                                 printf("\n\r");
  59.  
  60.                                 command_history_add(CMD);
  61.                                 return;
  62.  
  63.                         case 8: // BACKSPACE
  64.                                 if (CMD_POS > 0)
  65.                                         {
  66.                                         printf ("%c %c", 8, 8);
  67.                                         CMD_POS--;
  68.                                         }
  69.                                 break;
  70.  
  71.                         case 9: // TAB
  72.                                 break;
  73.  
  74.                         default:
  75.                                 if (CMD_POS < 255)
  76.                                         {
  77.                                         CMD[CMD_POS] = key;
  78.                                         CMD_POS++;
  79.                                         printf("%c", key);
  80.                                         }
  81.                                         break;
  82.                         };
  83.                 }
  84.         else    // îáðàáîòêà ðàñøèðåííûõ êëàâèø
  85.                 {
  86.                 key = (key>>8)&0xff;
  87. //              printf ("%d\n\r", key);
  88.  
  89.                 switch (key)
  90.                         {
  91.  
  92.                         case 72: // UP
  93.                                 for (hist = 0; hist < CMD_HISTORY_NUM; hist++)
  94.                                         {
  95.                                         command_clear();
  96.  
  97.                                         if (CMD_NUM < CMD_HISTORY_NUM-1)
  98.                                                 CMD_NUM++;
  99.                                         else
  100.                                                 CMD_NUM = 0;
  101.                                
  102.                                         printf( CMD_HISTORY[CMD_NUM] );
  103.                                         strcpy(CMD, CMD_HISTORY[CMD_NUM]);
  104.                                         CMD_POS = strlen(CMD);
  105.  
  106.                                         if (0!=strlen(CMD))
  107.                                                 break;
  108.                                         }
  109.  
  110.                                 break;
  111.  
  112.                         case 80: // DOWN
  113.                                 for (hist = 0; hist < CMD_HISTORY_NUM; hist++)
  114.                                         {
  115.                                         command_clear();
  116.  
  117.                                         if (CMD_NUM > 0)
  118.                                                 CMD_NUM--;
  119.                                         else
  120.                                                 CMD_NUM = CMD_HISTORY_NUM-1;
  121.  
  122.                                         printf( CMD_HISTORY[CMD_NUM] );
  123.                                         strcpy(CMD, CMD_HISTORY[CMD_NUM]);
  124.                                         CMD_POS = strlen(CMD);
  125.  
  126.                                         if (0!=strlen(CMD))
  127.                                                 break;
  128.                                         }
  129.                                 break;
  130.  
  131.                         };
  132.                 }
  133.                
  134.         }
  135. }
  136.  
  137.  
  138. /// ===========================================================
  139.  
  140. int command_get_cmd(char cmd[])
  141. {
  142. unsigned i;
  143. for (i=0;;i++)
  144.         {
  145.         cmd[i] = CMD[i];
  146.         if (0 == cmd[i])
  147.                 {
  148.                 i = -2;
  149.                 break;
  150.                 }
  151.         if ( iswhite(cmd[i]) )
  152.                 {
  153.                 cmd[i] = '\0';
  154.                 break;
  155.                 }
  156.         }
  157. return i+1;
  158. }
  159.  
  160. /// ===========================================================
  161.  
  162. void command_execute()
  163. {
  164. char cmd[256];
  165. char args[256];
  166. unsigned arg;
  167.  
  168. trim(CMD);
  169. arg = command_get_cmd(cmd);
  170.  
  171. if ( !strlen(cmd) )
  172.         return;
  173.  
  174. strcpy(args, CMD+arg);
  175. trim(args);
  176.  
  177. if ( !strcmp(cmd, "help") )
  178.         {
  179.         if (-1 == arg)
  180.                 cmd_help(NULL);
  181.         else
  182.                 cmd_help(args);
  183.         return;
  184.         }
  185.  
  186. if ( !strcmp(cmd, "ver") )
  187.         {
  188.         cmd_ver();
  189.         return;
  190.         }
  191.  
  192. if ( !strcmp(cmd, "cd") )
  193.         {
  194.         if (-1 == arg)
  195.                 cmd_cd(NULL);
  196.         else
  197.                 cmd_cd(args);
  198.  
  199.         if ( '/' != cur_dir[strlen(cur_dir)-1] )
  200.                 strcat(cur_dir, "/");
  201.  
  202.         return;
  203.         }
  204.  
  205. if ( !strcmp(cmd, "ls") )
  206.         {
  207.         if (-1 == arg)
  208.                 cmd_ls(cur_dir);
  209.         else
  210.                 cmd_ls(args);
  211.         return;
  212.         }
  213.  
  214. if ( !strcmp(cmd, "ps") )
  215.         {
  216.         cmd_ps();
  217.         return;
  218.         }
  219.  
  220. if ( !strcmp(cmd, "kill") )
  221.         {
  222.         if (-1 == arg)
  223.                 cmd_kill(NULL);
  224.         else
  225.                 cmd_kill(args);
  226.         return;
  227.         }
  228.  
  229. if ( !strcmp(cmd, "pwd") )
  230.         {
  231.         cmd_pwd();
  232.         return;
  233.         }
  234.  
  235. if ( !strcmp(cmd, "mkdir") )
  236.         {
  237.         if (-1 == arg)
  238.                 cmd_mkdir(NULL);
  239.         else
  240.                 cmd_mkdir(args);
  241.         return;
  242.         }
  243.  
  244. if ( !strcmp(cmd, "rmdir") )
  245.         {
  246.         if (-1 == arg)
  247.                 cmd_rmdir(NULL);
  248.         else
  249.                 cmd_rmdir(args);
  250.         return;
  251.         }
  252.  
  253. if ( !strcmp(cmd, "rm") )
  254.         {
  255.         if (-1 == arg)
  256.                 cmd_rm(NULL);
  257.         else
  258.                 cmd_rm(args);
  259.         return;
  260.         }
  261.  
  262. if ( !strcmp(cmd, "more") )
  263.         {
  264.         if (-1 == arg)
  265.                 cmd_more(NULL);
  266.         else
  267.                 cmd_more(args);
  268.         return;
  269.         }
  270.  
  271. if ( !strcmp(cmd, "echo") )
  272.         {
  273.         cmd_echo(args);
  274.         return;
  275.         }
  276.  
  277. if ( !strcmp(cmd, "exit") )
  278.         {
  279.         cmd_exit();
  280.         return;
  281.         }
  282.  
  283. if ( !strcmp(cmd, "date") )
  284.         {
  285.         cmd_date();
  286.         return;
  287.         }
  288.  
  289. if ( !strcmp(cmd, "about") )
  290.         {
  291.         cmd_about();
  292.         return;
  293.         }
  294.  
  295. if ( !strcmp(cmd, "free") )
  296.         {
  297.         cmd_free();
  298.         return;
  299.         }
  300.  
  301. if ( !strcmp(cmd, "reboot") )
  302.         {
  303.         cmd_reboot();
  304.         return;
  305.         }
  306.  
  307. if ( !strcmp(cmd, "touch") )
  308.         {
  309.         if (-1 == arg)
  310.                 cmd_touch(NULL);
  311.         else
  312.                 cmd_touch(args);
  313.         return;
  314.         }
  315.  
  316. if ( !strcmp(cmd, "alias") )
  317.         {
  318.         if (-1 == arg)
  319.                 cmd_alias(NULL);
  320.         else
  321.                 cmd_alias(args);
  322.         return;
  323.         }
  324.  
  325. if ( -1 != alias_search(CMD) )
  326.         {
  327.         strcpy(CMD, ALIASES+64*1024+256*alias_search(CMD));
  328.         command_execute();
  329.         return;
  330.         }
  331.  
  332. executable_run(cmd, args);
  333.  
  334. }
  335.  
  336. /// ===========================================================
  337.