Си — Говнокод.ру

Си / Говнокод #28867

0

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

/* Do the conversion */
  while (!isEmpty_2(stackPtr) && infix[i] != '\0') {
    c = infix[i++];

    if (my_isdigit(c) || my_isalpha(c)) {
      while (my_isdigit(c) || my_isalpha(c)) {
        postfix[j++] = c;
        c = infix[i++];
      }
      postfix[j++] = ' ';

      if (c == ')' || isOperator_2(c))
        i--;
    } else if (c == '(')
      push_2(&stackPtr, '(');
    else if (isOperator_2(c) == 1) {
      if (!isEmpty_2(stackPtr) && isOperator_2(stackTop_1(stackPtr))) {
        while (isOperator_2(stackTop_1(stackPtr)) &&
               (precedence_1(stackTop_1(stackPtr), c)) >= 0) {
          postfix[j++] = pop_2(&stackPtr);
          postfix[j++] = ' ';
        }
        push_2(&stackPtr, c);
      } else
        push_2(&stackPtr, c);
    } else if (c == ')') {
      if (!isEmpty_2(stackPtr)) {
        c = pop_2(&stackPtr);

        while (!isEmpty_2(stackPtr) && c != '(') {
          postfix[j++] = c;
          postfix[j++] = ' ';
          c = pop_2(&stackPtr);
        }
      }
    }
  }
  postfix[j] = '\0';
}

int precedence_1(char operator1, char operator2) {
  int result = 1;

  switch (operator1) {
  case '^':
    if (operator2 == '^')
      result = 0;
    break;
  case '*':
  case '/':
  case '%':
    switch (operator2) {
    case '^':
      result = -1;
      break;
    case '*':
    case '/':
    case '%':
      result = 0;
      break;
    default:
      break;
    }
    break;
  case '+':
  case '-':
    switch (operator2) {
    case '-':
    case '+':
      result = 0;
      break;
    default:
      result = -1;
      break;
    }
    break;
  }

  return result;
}

void push_2(StackNodePtr_2 *topPtr, int info) {
  StackNodePtr_2 newPtr;

  newPtr = malloc(sizeof(StackNode_2)); /* Now points to a place in memory*/

  if (newPtr != NULL) {
    newPtr->data = info;
    newPtr->nextPtr = *topPtr;
    *topPtr = newPtr;
  } else
    printf("%c not inserted. No memory available.\n", info);
}

Инклуды для симплтрона 2

gne4do, 02 Октября 2023

Комментарии (0)

Си / Говнокод #28866

0

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

#include <ctype.h> 
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MEM 100
#define READ 10
#define WRITE 11
#define LOAD 20
#define STORE 21
#define ADD 30
#define SUBSTRACT 31
#define DIVIDE 32
#define MUL 33
#define BRANCH 40
#define BRANCHNEG 41
#define BRANCHZERO 42
#define HALT 43

int count_down = 99;

struct stackNode_2 {
  int data;
  struct stackNode_2 *nextPtr;
};

typedef struct stackNode_2 StackNode_2;
typedef StackNode_2 *StackNodePtr_2;

typedef struct tableEntry {
  char symbol[10];
  char type;
  int location;

} data;

int my_isdigit(char alpha);
int my_isalpha(char alpha);
int isOperator_2(char c);

char stackTop_1(StackNodePtr_2 topPtr);

int helper_search_1(data *base, char *token, int run);

int helper_search_2(data *base, char *token, int run);

int (*helper_search[2])(data *base, char *token, int run) = {helper_search_1,
                                                             helper_search_2};

int search_in_base(data *intro_search, char *str_tok_search);
int helper_search_base(data *base, char *token, int run);

void convertToPostfix_1(char infix[], char postfix[]);

int pop_2(StackNodePtr_2 *topPtr);
void push_2(StackNodePtr_2 *topPtr, int info);
int isEmpty_2(StackNodePtr_2 topPtr);

int precedence_1(char operator1, char operator2);

void convertToPostfix_1(char infix[], char postfix[]) {
  int i = 0, j = 0;
  char c;

  /* Push left parenthesis to stack */
  StackNodePtr_2 stackPtr = NULL;
  push_2(&stackPtr, '(');

  /* Add right parenthesis to end of infix */
  while (infix[i] != '\0')
    i++;

  infix[i++] = ')';
  infix[i] = '\0';

  i = 0;

Инклуды для симплтрона 1

gne4do, 02 Октября 2023

Комментарии (0)

Си / Говнокод #28865

0

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

int calculate_2(int op1, int op2, char operator, int memory_smp[],
                int *count_command) {

  int result = 0;

  switch (operator) {
  case '+':

    memory_smp[*count_command] = (2000 + op1);
    (*count_command)++;

    memory_smp[*count_command] = (3000 + op2);
    (*count_command)++;

    memory_smp[*count_command] = (2100 + count_down);

    (*count_command)++;
    result = count_down;
    count_down--;

    // result = op1 + op2;
    break;
  case '-':
    memory_smp[*count_command] = (2000 + op1);
    (*count_command)++;
    memory_smp[*count_command] = (3100 + op2);
    (*count_command)++;
    memory_smp[*count_command] = (2100 + count_down);
    (*count_command)++;
    result = count_down;
    count_down--;
    // result = op1 - op2;
    break;
  case '*':
    memory_smp[*count_command] = (2000 + op1);
    (*count_command)++;
    memory_smp[*count_command] = (3300 + op2);
    (*count_command)++;
    memory_smp[*count_command] = (2100 + count_down);
    (*count_command)++;
    result = count_down;
    count_down--;
    // result = op1 * op2;
    break;
  case '/':

    memory_smp[*count_command] = (2000 + op1);
    (*count_command)++;
    memory_smp[*count_command] = (3200 + op2);
    (*count_command)++;
    memory_smp[*count_command] = (2100 + count_down);
    (*count_command)++;
    result = count_down;
    count_down--;
    //   result = op1 / op2;
    break;
  /*
  case '^':
    result = pow(op1, op2);
    break;
  case '%':
    result = op1 % op2;
    break;
  */
  default:
    break;
  }

  return result;
}

Симлтрон из Дейтелов
5

gne4do, 02 Октября 2023

Комментарии (0)

Си / Говнокод #28864

0

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

file_buf = fopen(argv[2], "w");

  for (d = 0; mem_smp[d] != 0; d++) {

    fprintf(file_buf, "%d %d\n", d, mem_smp[d]);
  }

  for (d = 0; (symbolTable + d)->type != 'q'; d++) {

    if ((symbolTable + d)->type == 'C') {
      count_cmd = atoi((symbolTable + d)->symbol);

      fprintf(file_buf, "%d %d\n", (symbolTable + d)->location, count_cmd);
    }
  }
  fclose(file_buf);

  return 0;
}

int past_in_table_cons_or_value(data *table, char *str_tok) {

  int search_in_table(data * intro_search, char *str_tok_search);

  int find = search_in_table(table, str_tok);

  if ((table + find)->type == 'q') {

    if (my_isalpha(*str_tok)) {
      (table + find)->symbol[0] = *str_tok; //  or  str_tok don't atoi

    } else {
      strcpy((table + find)->symbol, str_tok);
    }

    (table + find)->type = my_isalpha(*str_tok) ? 'V' : 'C';

    (table + find)->location = count_down;

    count_down--;
  }

  return (table + find)->location;
}

int evaluatePostfixExpression_2(char *expr, int memory_smp[],
                                int *count_command) {
  StackNodePtr_2 stackPtr = NULL;
  char c;
  int x, y;
  int i = 0, mult = 1, num = 0;

  while (expr[i] != '\0') {
    mult = 1;
    num = 0;
    c = expr[i];
    if (my_isdigit(c)) {
      while (my_isdigit(c)) {
        num *= mult;
        num += c - 48;
        c = expr[++i];
        mult *= 10;
      }
      --i;
      push_2(&stackPtr, num);
    } else if (isOperator_2(c)) {
      if (isEmpty_2(stackPtr)) {
        printf("Invalid postfix expression!\n");
        return 0;
      }
      x = pop_2(&stackPtr);

      if (isEmpty_2(stackPtr)) {
        printf("Invalid postfix expression!\n");
        return 0;
      }
      y = pop_2(&stackPtr);

      push_2(&stackPtr, calculate_2(y, x, c, memory_smp, &(*count_command)));
    }
    i++;
  }

  if (isEmpty_2(stackPtr)) {
    printf("Invalid postfix expression!\n");
    return 0;
  }

  return pop_2(&stackPtr);
}

int calculate_2(int op1, int op2, char operator, int memory_smp[],
                int *count_command) {

  int result = 0;

Симплтрон из задачи Дейтелов
4

gne4do, 02 Октября 2023

Комментарии (0)

Си / Говнокод #28863

0

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

if (sign_ch == 0) {
          swp = val_if[0];
          val_if[0] = val_if[1];
          val_if[1] = swp;
        }

        mem_smp[count_cmd] = 2000 + (symbolTable + val_if[1])->location;
        count_cmd++;
        mem_smp[count_cmd] = 3100 + (symbolTable + val_if[0])->location;
        count_cmd++;

        if (goto_flag == 1) {
          flags[count_cmd] = second_buf;
          mem_smp[count_cmd] = rn_data[ab].data[0];
          count_cmd++;
        } else {
          mem_smp[count_cmd] = rn_data[ab].data[0] + second_buf;
          count_cmd++;
        }

        if (rn_data[ab].type == 2) {

          mem_smp[count_cmd] = 2000 + (symbolTable + val_if[0])->location;
          count_cmd++;
          mem_smp[count_cmd] = 3100 + (symbolTable + val_if[1])->location;
          count_cmd++;

          if (goto_flag == 1) {
            flags[count_cmd] = second_buf;
            mem_smp[count_cmd] = rn_data[ab].data[1];
            count_cmd++;
          } else {
            mem_smp[count_cmd] = rn_data[ab].data[1] + second_buf;
            count_cmd++;
          }
        }

      }

      else if (my_strcmp(buffer, "goto") == 0) {

        second_buf = 0;
        goto_flag = 0;

        intro_buffer = strtok(NULL, " ");
        second_buf = goto_search(symbolTable, intro_buffer);

        if (second_buf == 0) {
          second_buf = atoi(intro_buffer);
          goto_flag = 1;
        }

        if (goto_flag == 1) {
          flags[count_cmd] = second_buf;
          mem_smp[count_cmd] = 4000;
          count_cmd++;
        } else {
          mem_smp[count_cmd] = 4000 + second_buf;
          count_cmd++;
        }
      }

      else if (my_strcmp(buffer, "print") == 0) {
        intro_buffer = strtok(NULL, " ");
        second_buf = search_in_table(symbolTable, intro_buffer);
        mem_smp[count_cmd] = 1100 + (symbolTable + second_buf)->location;
        count_cmd++;

      }

      else if (my_strcmp(buffer, "input") == 0) {
        intro_buffer = strtok(NULL, " ");
        past_in_table_cons_or_value(symbolTable, intro_buffer);
        second_buf = search_in_table(symbolTable, intro_buffer);
        mem_smp[count_cmd] = 1000 + (symbolTable + second_buf)->location;
        count_cmd++;
      } else if (my_strcmp(buffer, "end") == 0) {

        mem_smp[count_cmd] = 4300;
      }

      ////////////////////////////////////////////////////////////////////////
      count_table_extra = count_cmd;
      /////////////////////////////////////////////////////////////////////////
    }
  }

  for (d = 0; mem_smp[d] != 0; d++) {
    if (flags[d] != -1) {

      sprintf(&postfix[0], "%d", flags[d]);

      goto_flag = search_in_table(symbolTable, postfix);
      mem_smp[d] += (symbolTable + goto_flag)->location;
    }
  }

Симплтрон из задачи Дейтелов
3

gne4do, 02 Октября 2023

Комментарии (0)

Си / Говнокод #28862

0

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

int second_buf = 0;

  for (; d != 100; d++) {

    strcpy((symbolTable + d)->symbol, "0");
    (symbolTable + d)->location = 0;
    (symbolTable + d)->type = 'q';
    mem_smp[d] = 0;
    flags[d] = -1;
  }

  printf("%s\n", argv[0]);

  file_buf = fopen(argv[1], "r");

  for (d = 0; feof(file_buf) == 0; ++d) {

    fgets(&buf_data[d][0], 150, file_buf);
  }

  fclose(file_buf);

  memcpy(copy_buf_data, buf_data, sizeof(char) * 150 * 150);

  for (d = 0; buf_data[d][0] != 0; d++) {

    buffer = strtok(&buf_data[d][0], " ");

    for (; buffer != NULL; buffer = strtok(NULL, " ")) {

      if (token_string_count == 0 && my_isdigit(*buffer)) {

        count_table_intro = search_in_base(symbolTable, buffer);

        strcpy((symbolTable + count_table_intro)->symbol, buffer);

        (symbolTable + count_table_intro)->type = 'L';

        (symbolTable + count_table_intro)->location = count_table_extra;
      }

      if (rem_break(buffer) == 1) {

        (symbolTable + count_table_intro)->location = count_table_extra;

        break;
      }

      else if (my_strcmp(buffer, "let") == 0) {

        strcpy(infix, &copy_buf_data[d][7]);
        convertToPostfix_1(infix, postfix);
        save_left_side = let_past(symbolTable, postfix, post_buf);

        save_exp = evaluatePostfixExpression_2(post_buf, mem_smp, &count_cmd);
        mem_smp[count_cmd] = (2000 + save_exp);
        count_cmd++;

        mem_smp[count_cmd] = (2100 + save_left_side);
        count_cmd++;

      }

      else if (my_strcmp(buffer, "if") == 0) {

        strcpy(infix, &copy_buf_data[d][5]);
        intro_buffer = strtok(infix, " ");
        second_buf = 0;
        for (count_if = 0, sign_ch = 1, ab = 0; intro_buffer != (char *)'\0';
             intro_buffer = strtok(NULL, " "), count_if++) {

          if (!my_strcmp(intro_buffer, "goto")) {
            goto_flag = 0;
            intro_buffer = strtok(NULL, " ");

            second_buf = goto_search(symbolTable, intro_buffer);

            if (second_buf == 0) {
              second_buf = atoi(intro_buffer);
              goto_flag = 1;
            }

          }

          else if (strstr(comparison_signs, intro_buffer)) {
            ab = intro_buffer[0] + intro_buffer[1];

            sign_ch = !(ab == 60);

          }

          else if ((isalnum(*intro_buffer))) {

            past_in_table_cons_or_value(symbolTable, intro_buffer);

            val_if[cnt++] = search_in_table(symbolTable, intro_buffer);
          }
        }

Симплтрон из задачи Дейтелов
2

gne4do, 02 Октября 2023

Комментарии (0)

Си / Говнокод #28861

0

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

#include <ctype.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int evaluatePostfixExpression_2(char *, int memory_smp[], int *count_command);
int calculate_2(int, int, char, int memory_smp[], int *count_command);

typedef struct mode_intro {
  int type;
  int data[2];

} expr_if;

int main(int argc, char *argv[]) {

  expr_if rn_data[125];

  /*  !=   */
  rn_data[94].type = 2;
  rn_data[94].data[0] = 4100;
  rn_data[94].data[1] = 4100;
  /*  !=   */

  /*  ==   */
  rn_data[122].type = 1;
  rn_data[122].data[0] = 4200;
  /*  ==   */

  /*  <=   */
  rn_data[121].type = 2;
  rn_data[121].data[0] = 4200;
  rn_data[121].data[1] = 4100;
  /*  <=   */

  /* < Øèâîðîò íà âûâîðîò  */
  rn_data[60].type = 1;
  rn_data[60].data[0] = 4100;
  /*  <   */

  /*  >=   */
  rn_data[123].type = 2;
  rn_data[123].data[0] = 4200;
  rn_data[123].data[1] = 4100;
  /*  >=   */

  /* > */
  rn_data[62].type = 1;
  rn_data[62].data[0] = 4100;
  /* > */

  char infix[150];
  char postfix[150];

  int line_simple_comands_input_print(int cmd, data *table, int token,
                                      int memory[]);

  int past_in_table_cons_or_value(data * table, char *str_tok);
  int ab = 0;
  int swp = 0;
  int goto_search(data * table, char *token);

  int search_cmd(char *dict[15], char *token);
  char *comparison_signs = "> < <= >= == !=";
  int token_string_count = 0;
  data symbolTable[100];

  int cnt = 0;
  int d = 0;
  int count_if = 0;
  int flags[100];

  int mem_smp[100];
  char copy_buf_data[150][150] = {{0}};
  char post_buf[150];
  int count_cmd = 0;

  int sign_ch;
  FILE *file_buf;

  char *buffer = 0;
  char *intro_buffer = 0;
  int save_left_side = 0, save_exp = 0;
  int goto_flag = 0;

  int count_table_intro = 0;
  int count_table_extra = 0;
  char name_file[100];

  char buffer_postfix[150];
  char buf_data[150][150] = {{0}};
  int val_if[3] = {0};

  int data_if[150] = {0};

 data_if[60] = 4100;
 data_if[61] = 1;

Симплтрон из задачи по Дейтелам
1

gne4do, 02 Октября 2023

Комментарии (1)

Си / Говнокод #28834

0

1
2
3
4
5
6
7
8
9

static inline int is_openvpn_handshake(const char *pktdata, unsigned int pktlen) {
    /*
     * 0x38 is P_CONTROL_HARD_RESET_CLIENT_V2 + peer_id(0),
     * 0x50 is P_CONTROL_HARD_RESET_CLIENT_V3 + peer_id(0)
     */
    return pktlen >= 16
           && ntohs(((uint16_t*)pktdata)[0]) == pktlen - 2
           && (pktdata[2] == '\x38' || pktdata[2] == '\x50');
}

Код обнаружения протокола OpenVPN по рукопожатию.

ropuJIJIa, 10 Августа 2023

Комментарии (45)

Си / Говнокод #28798

0

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

struct node
{
    void *data;

    struct node *head;
    struct node *tail;
};
struct list
{
    int size;

    struct node *head;
    struct node *tail;

    void *(*alloc_node)(size_t);
    void *(*alloc_data)(size_t);
    void (*free_node)(void *);
    void (*free_data)(void *);
};

typedef struct node node_t;
typedef struct list list_t;

void list_init(list_t *list)
{
    list->size = 0;

    list->head = (node_t*)list;
    list->tail = (node_t*)list;

    list->alloc_node = &malloc;
    list->alloc_data = &malloc;
    list->free_node = &free;
    list->free_data = &free;
}
void list_link(struct node *head, struct node *tail)
{
    head->tail = tail;
    tail->head = head;
}
void *push_head(list_t *list, node_t *head, size_t size)
{
    node_t *node = list->alloc_node(sizeof(node_t));
    void   *data = list->alloc_data(size);

    node->data = data;
    list_link(node, head->tail);
    list_link(head, node);

    list->size++;
    return data;
}
void *push_tail(list_t *list, node_t *tail, size_t size)
{
    node_t *node = list->alloc_node(sizeof(node_t));
    void   *data = list->alloc_data(size);

    node->data = data;
    list_link(tail->head, node);
    list_link(node, tail);

    list->size++;
    return data;
}
void pop(list_t *list, node_t *node)
{
    list_link(node->head, node->tail);
    list->size--;

    void *data = node->data;

    list->free_node(node);
    list->free_data(data);
}
void print(struct list *list)
{
    printf("\n====\n");

    printf("size: %ld \n", list->size);

    int i = 0;

    for(node_t *node = list->head; node != list; node = node->head)
    {
        printf("index: %ld number: %ld \n", i, *(int*)(node->data));
        i++;
    }
}

struct list lst;

    list_init(&lst);

    print(&lst);

    void *data;
    data = push_tail(&lst, lst.tail, 4);
    *(int*)data = 1;

итак скажите про название функций про то каких функций не хватает + alloc и free поля не трогать это мне нужно ТОЛЬКО НЕ советуйте перейти на с++ и использовать чтото другое(std::list)

CodeTux, 16 Июня 2023

Комментарии (23)

Си / Говнокод #28745

0

1
2

printf ("%d file%s processed", nfiles,
        nfiles != 1 ? "s" : "");

Из официального гайда "GNU" по написанию кода на "C".

JloJle4Ka, 17 Апреля 2023

Комментарии (1005)

Говнокод: по колено в коде.

Си / Говнокод #28867

Си / Говнокод #28866

Си / Говнокод #28865

Си / Говнокод #28864

Си / Говнокод #28863

Си / Говнокод #28862

Си / Говнокод #28861

Си / Говнокод #28834

Си / Говнокод #28798

Си / Говнокод #28745