URL https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [Open8 Tools/] [open8_src/] [open8_as/] [parse.c] - Blame information for rev 289

Go to most recent revision | Details | Compare with Previous | View Log


 
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "defines.h"
 
#include "parse.h"
#include "pass_1.h"
#include "stack.h"
 
 
int input_number_error_msg = YES, ss, string_size, input_float_mode = OFF, parse_floats = YES;
int newline_beginning = ON;
char label[MAX_NAME_LENGTH], xyz[256];
char unevaluated_expression[256];
char expanded_macro_string[256];
double flo;
 
extern int i, size, d, macro_active;
extern char *buffer, tmp[4096], cp[256];
extern struct active_file_info *active_file_info_first, *active_file_info_last, *active_file_info_tmp;
extern struct definition *defines, *tmp_def, *next_def;
extern struct macro_runtime *macro_runtime_current;
extern int latest_stack;
 
int operand_hint;
 
 
int compare_next_token(char *in, int s) {
 
  int a, t, d, k;
  char e;
 
 
  a = i;
  for (e = buffer[a]; e == ' ' || e == ',' || e == 0x0A; e = buffer[++a]);
 
  /* MACRO mode? */
  if (macro_active != 0 && e == '\\') {
    for (d = 0, k = 0; k < 16; k++) {
      e = buffer[++a];
      if (e >= '0' && e <= '9')
        d = (d * 10) + e - '0';
      else
        break;
    }
 
    if (d > macro_runtime_current->supplied_arguments) {
      if (input_number_error_msg == YES) {
        sprintf(xyz, "COMPARE_NEXT_SYMBOL: Macro \"%s\" wasn't called with enough arguments.\n", macro_runtime_current->macro->name);
        print_error(xyz, ERROR_NONE);
      }
      return FAILED;
    }
 
    a = macro_runtime_current->argument_data[d - 1]->start;
 
    e = buffer[a];
    for (t = 0; t < s && e != ' ' && e != ',' && e != 0x0A; ) {
      if (toupper(in[t]) != toupper(e))
        return FAILED;
      t++;
      e = buffer[++a];
    }
  }
  /* not in MACRO mode */
  else {
    for (t = 0; t < s && e != ' ' && e != ',' && e != 0x0A; ) {
      if (toupper(in[t]) != toupper(e))
        return FAILED;
      t++;
      e = buffer[++a];
    }
  }
 
  if (t == s)
    return SUCCEEDED;
  else
    return FAILED;
}
 
 
int input_next_string(void) {
 
  char e;
  int k, d;
 
 
  for (e = buffer[i++]; e == ' ' || e == ','; e = buffer[i++]);
 
  if (e == 0x0A)
    return INPUT_NUMBER_EOL;
 
  /* last choice is a label */
  tmp[0] = e;
  for (k = 1; k < MAX_NAME_LENGTH - 1; k++) {
    e = buffer[i++];
    if (e == 0x0A || e == ',') {
      i--;
      break;
    }
    else if (e == ' ')
      break;
    tmp[k] = e;
  }
 
  if (k == MAX_NAME_LENGTH - 1) {
    if (input_number_error_msg == YES) {
      sprintf(xyz, "The string is too long (max %d bytes).\n", MAX_NAME_LENGTH - 1);
      print_error(xyz, ERROR_NUM);
    }
    return FAILED;
  }
 
  tmp[k] = 0;
 
  /* expand eg. \1 and \@ */
  if (macro_active != 0) {
    d = 0;
    if (expand_macro_arguments(tmp, &d) == FAILED)
      return FAILED;
    if (d != 0)
      strcpy(tmp, expanded_macro_string);
  }
 
  return SUCCEEDED;
}
 
 
int input_number(void) {
 
  unsigned char e, ee;
  int k, p, q;
  double dn;
 
 
  operand_hint = HINT_NONE;
 
  for (e = buffer[i++]; e == ' ' || e == ','; e = buffer[i++]);
 
  if (e == 0x0A)
    return INPUT_NUMBER_EOL;
 
  /* check the type of the expression */
  p = i;
  ee = e;
  while (ee != 0x0A) {
    /* string / symbol -> no calculating */
    if (ee == '"' || ee == ',' || (ee == '=' && buffer[p] == '=') ||
        (ee == '!' && buffer[p] == '='))
      break;
    if (ee == '-' || ee == '+' || ee == '*' || ee == '/' || ee == '&' || ee == '|' || ee == '^' ||
        ee == '<' || ee == '>' || ee == '#' || ee == '~') {
      /* launch stack calculator */
      p = stack_calculate(&buffer[i - 1], &d);
      if (p == STACK_CALCULATE_DELAY)
        break;
      else if (p == STACK_RETURN_LABEL)
        return INPUT_NUMBER_ADDRESS_LABEL;
      else
        return p;
    }
    ee = buffer[p];
    p++;
  }
 
  /* MACRO */
  if (macro_active != 0 && e == '\\') {
 
    struct macro_argument *ma;
 
 
    if (buffer[i] == '@') {
      i++;
      d = macro_runtime_current->macro->calls - 1;
      return SUCCEEDED;
    }
 
    for (d = 0, k = 0; k < 4; k++) {
      e = buffer[i++];
      if (e >= '0' && e <= '9')
        d = (d * 10) + (e - '0');
      else {
        i--;
        break;
      }
    }
 
    if (d > macro_runtime_current->supplied_arguments) {
      sprintf(xyz, "Referencing argument number %d inside macro \"%s\". The macro has only %d arguments.\n", d, macro_runtime_current->macro->name, macro_runtime_current->supplied_arguments);
      print_error(xyz, ERROR_NUM);
      return FAILED;
    }
 
    /* return the macro argument */
    ma = macro_runtime_current->argument_data[d - 1];
    k = ma->type;
 
    if (k == INPUT_NUMBER_ADDRESS_LABEL)
      strcpy(label, ma->string);
    else if (k == INPUT_NUMBER_STRING) {
      strcpy(label, ma->string);
      string_size = strlen(ma->string);
    }
    else if (k == INPUT_NUMBER_STACK)
      latest_stack = ma->value;
    else if (k == SUCCEEDED)
      d = ma->value;
    else {
      print_error("Macro argument list has been corrupted! Please send a bug report!\n", ERROR_ERR);
      return FAILED;
    }
 
    return k;
  }
 
  /* is it a hexadecimal value? */
  d = 0;
  if (e >= '0' && e <= '9') {
    for (k = 0; 1; k++) {
      if (buffer[i+k] >= '0' && buffer[i+k] <= '9')
        continue;
      if (buffer[i+k] >= 'a' && buffer[i+k] <= 'f')
        continue;
      if (buffer[i+k] >= 'A' && buffer[i+k] <= 'F')
        continue;
      if (buffer[i+k] == 'h' || buffer[i+k] == 'H') {
        d = 1;
        break;
      }
      break;
    }
  }
 
  if (e == '$' || d == 1) {
    if (d == 1)
      i--;
    for (d = 0, k = 0; k < 8; k++, i++) {
      e = buffer[i];
      if (e >= '0' && e <= '9')
        d = (d << 4) + e - '0';
      else if (e >= 'A' && e <= 'F')
        d = (d << 4) + e - 'A' + 10;
      else if (e >= 'a' && e <= 'f')
        d = (d << 4) + e - 'a' + 10;
      else if (e == 'h' || e == 'H') {
        i++;
        e = buffer[i];
        break;
      }
      else
        break;
    }
 
    if (e == '.') {
      e = buffer[i+1];
      if (e == 'b' || e == 'B') {
        operand_hint = HINT_8BIT;
        i += 2;
      }
      else if (e == 'w' || e == 'W') {
        operand_hint = HINT_16BIT;
        i += 2;
      }
    }
 
    return SUCCEEDED;
  }
 
  if (e >= '0' && e <= '9') {
    q = 0;
    flo = e-'0';
    dn = 0.1;
    for (k = 0; k < 9; k++, i++) {
      e = buffer[i];
      if (e >= '0' && e <= '9') {
        if (q == 0) {
          /* still parsing an integer */
          flo = flo*10 + e-'0';
        }
        else {
          flo = flo + dn*(e-'0');
          dn /= 10.0;
        }
      }
      else if (e == '.') {
        if (q == 1) {
          print_error("Syntax error.\n", ERROR_NUM);
          return FAILED;
        }
        e = buffer[i+1];
        if (e >= '0' && e <= '9') {
          /* float mode, read decimals */
          if (parse_floats == NO)
            break;
          q = 1;
        }
        else if (e == 'b' || e == 'B') {
          operand_hint = HINT_8BIT;
          i += 2;
          break;
        }
        else if (e == 'w' || e == 'W') {
          operand_hint = HINT_16BIT;
          i += 2;
          break;
        }
      }
      else
        break;
    }
 
    /* drop the decimals */
    d = flo;
 
    if (q == 1 && input_float_mode == ON)
      return INPUT_NUMBER_FLOAT;
 
    return SUCCEEDED;
  }
 
  if (e == '%') {
    for (d = 0, k = 0; k < 32; k++, i++) {
      e = buffer[i];
      if (e == '0' || e == '1')
        d = (d << 1) + e - '0';
      else
        break;
    }
 
    if (e == '.') {
      e = buffer[i+1];
      if (e == 'b' || e == 'B') {
        operand_hint = HINT_8BIT;
        i += 2;
      }
      else if (e == 'w' || e == 'W') {
        operand_hint = HINT_16BIT;
        i += 2;
      }
    }
 
    return SUCCEEDED;
  }
 
  if (e == '\'') {
    d = buffer[i++];
    e = buffer[i];
    if (e != '\'') {
      if (input_number_error_msg == YES) {
        sprintf(xyz, "Got '%c' (%d) when expected \"'\".\n", e, e);
        print_error(xyz, ERROR_NUM);
      }
      return FAILED;
    }
    i++;
 
    return SUCCEEDED;
  }
 
  if (e == '"') {
 
    for (k = 0; k < MAX_NAME_LENGTH - 1; ) {
      e = buffer[i++];
 
      if (e == '\\' && buffer[i] == '"') {
        label[k++] = '"';
        i++;
        continue;
      }
 
      if (e == '"')
        break;
 
      if (e == 0 || e == 0x0A) {
        print_error("String wasn't terminated properly.\n", ERROR_NUM);
        return FAILED;
      }
 
      label[k++] = e;
    }
 
    label[k] = 0;
 
    /* expand eg. \1 and \@ */
    if (macro_active != 0) {
      d = 0;
      if (expand_macro_arguments(label, &d) == FAILED)
        return FAILED;
      if (d != 0) {
        strcpy(label, expanded_macro_string);
        k = strlen(label);
      }
    }
 
    if (k == MAX_NAME_LENGTH - 1) {
      if (input_number_error_msg == YES) {
        sprintf(xyz, "The string is too long (max %d bytes).\n", MAX_NAME_LENGTH - 1);
        print_error(xyz, ERROR_NUM);
      }
      return FAILED;
    }
 
    label[k] = 0;
    string_size = k;
    return INPUT_NUMBER_STRING;
  }
 
  /* last choice is a label */
  label[0] = e;
  for (k = 1; k < MAX_NAME_LENGTH - 1; k++) {
    e = buffer[i++];
    if (e == 0x0A || e == ')' || e == ',' || e == ']') {
      i--;
      break;
    }
    else if (e == ' ')
      break;
    label[k] = e;
  }
 
  if (k == MAX_NAME_LENGTH - 1) {
    if (input_number_error_msg == YES) {
      sprintf(xyz, "The label is too long (max %d bytes).\n", MAX_NAME_LENGTH - 1);
      print_error(xyz, ERROR_NUM);
    }
    return FAILED;
  }
 
  /* size hint? */
  if (label[k-2] == '.') {
    if (label[k-1] == 'b' || label[k-1] == 'B') {
      operand_hint = HINT_8BIT;
      k -= 2;
    }
    else if (label[k-1] == 'w' || label[k-1] == 'W') {
      operand_hint = HINT_16BIT;
      k -= 2;
    }
  }
 
  label[k] = 0;
 
  /* expand eg. \1 and \@ */
  if (macro_active != 0) {
    d = 0;
    if (expand_macro_arguments(label, &d) == FAILED)
      return FAILED;
    if (d != 0)
      strcpy(label, expanded_macro_string);
  }
 
  /* check if the label is actually a definition */
  tmp_def = defines;
  while (tmp_def != NULL) {
    if (strcmp(label, tmp_def->alias) == 0) {
      if (tmp_def->type == DEFINITION_TYPE_VALUE) {
        d = tmp_def->value;
        return SUCCEEDED;
      }
      else if (tmp_def->type == DEFINITION_TYPE_STACK) {
        /* skip stack definitions -> use its name instead */
      }
      else {
        string_size = tmp_def->size;
        memcpy(label, tmp_def->string, string_size);
        label[string_size] = 0;
        return INPUT_NUMBER_STRING;
      }
    }
    tmp_def = tmp_def->next;
  }
 
  return INPUT_NUMBER_ADDRESS_LABEL;
}
 
 
int get_next_token(void) {
 
  int q;
 
 
  while (1) {
    if (i == size)
      break;
    if (buffer[i] == ' ') {
      i++;
      newline_beginning = OFF;
      continue;
    }
    if (buffer[i] == 0x0A) {
      i++;
      next_line();
      continue;
    }
    break;
  }
 
  if (buffer[i] == '"') {
    for (ss = 0, i++; buffer[i] != 0x0A && buffer[i] != '"'; ) {
      if (buffer[i] == '\\' && buffer[i + 1] == '"') {
        tmp[ss++] = '"';
        i += 2;
      }
      else
        tmp[ss++] = buffer[i++];
    }
 
    if (buffer[i] == 0x0A) {
      print_error("GET_NEXT_TOKEN: String wasn't terminated properly.\n", ERROR_NONE);
      return FAILED;
    }
    tmp[ss] = 0;
    i++;
 
    /* expand eg. \1 and \@ */
    if (macro_active != 0) {
      q = 0;
      if (expand_macro_arguments(tmp, &q) == FAILED)
        return FAILED;
      if (q != 0) {
        strcpy(tmp, expanded_macro_string);
        ss = strlen(tmp);
      }
    }
 
    return GET_NEXT_TOKEN_STRING;
  }
 
  if (buffer[i] == '.') {
    tmp[0] = '.';
    i++;
    for (ss = 1; buffer[i] != 0x0A && buffer[i] != ' ' && ss <= MAX_NAME_LENGTH; ) {
      tmp[ss] = buffer[i];
      cp[ss - 1] = toupper((int)buffer[i]);
      i++;
      ss++;
    }
    cp[ss - 1] = 0;
  }
  else if (buffer[i] == '=' || buffer[i] == '>' || buffer[i] == '<' || buffer[i] == '!') {
    for (ss = 0; buffer[i] != 0x0A && (buffer[i] == '=' || buffer[i] == '!' || buffer[i] == '<' || buffer[i] == '>')
           && ss <= MAX_NAME_LENGTH; tmp[ss++] = buffer[i++]);
  }
  else {
    for (ss = 0; buffer[i] != 0x0A && buffer[i] != ',' && buffer[i] != ' ' && ss <= MAX_NAME_LENGTH; ) {
      tmp[ss] = buffer[i];
      ss++;
      i++;
    }
    if (buffer[i] == ',')
      i++;
  }
 
  if (ss > MAX_NAME_LENGTH) {
    print_error("GET_NEXT_TOKEN: Too long for a token.\n", ERROR_NONE);
    return FAILED;
  }
 
  tmp[ss] = 0;
 
  /* expand eg. \1 and \@ */
  if (macro_active != 0) {
    q = 0;
    if (expand_macro_arguments(tmp, &q) == FAILED)
      return FAILED;
    if (q != 0) {
      strcpy(tmp, expanded_macro_string);
      ss = strlen(tmp);
    }
  }
 
  return SUCCEEDED;
}
 
 
int skip_next_token(void) {
 
  for (; buffer[i] == ' ' || buffer[i] == ','; i++);
 
  if (buffer[i] == 0x0A)
    return FAILED;
 
  if (buffer[i] == '"') {
    for (i++; buffer[i] != 0x0A && buffer[i] != '"'; i++);
    if (buffer[i] == 0x0A) {
      print_error("SKIP_NEXT_TOKEN: String wasn't terminated properly.\n", ERROR_NONE);
      return FAILED;
    }
    i++;
 
    return SUCCEEDED;
  }
 
  for (; buffer[i] != 0x0A && buffer[i] != ' ' && buffer[i] != ','; i++);
 
  return SUCCEEDED;
}
 
 
int expand_macro_arguments(char *in, int *s) {
 
  char t[256];
  int i, k, d;
 
 
  for (i = 0; i < MAX_NAME_LENGTH; i++) {
    if (in[i] == '\\') {
      if (in[i + 1] == '"' || in[i + 1] == 'n' || in[i + 1] == '\\') {
        expanded_macro_string[i] = in[i];
        i++;
        expanded_macro_string[i] = in[i];
        continue;
      }
      break;
    }
    expanded_macro_string[i] = in[i];
    if (in[i] == 0)
      return SUCCEEDED;
  }
 
  k = i;
  i++;
 
  (*s)++;
 
  if (in[i] == '@') {
    i++;
    sprintf(&expanded_macro_string[k], "%d%c", macro_runtime_current->macro->calls - 1, 0);
    k = strlen(expanded_macro_string);
 
    for (; i < MAX_NAME_LENGTH; i++, k++) {
      expanded_macro_string[k] = in[i];
      if (in[i] == 0) {
        break;
      }
    }
 
    strcpy(t, expanded_macro_string);
    expand_macro_arguments(t, &d);
    return SUCCEEDED;
  }
 
  if (in[i] <= '0' || in[i] >= '9') {
    if (input_number_error_msg == YES) {
      sprintf(xyz, "EXPAND_MACRO_ARGUMENTS: Unsupported special character '%c'.\n", in[i]);
      print_error(xyz, ERROR_NUM);
    }
    return FAILED;
  }
 
  for (d = 0; in[i] != 0; i++) {
    if (in[i] >= '0' && in[i] <= '9')
      d = (d * 10) + in[i] - '0';
    else
      break;
  }
 
  if (d > macro_runtime_current->supplied_arguments) {
    if (input_number_error_msg == YES) {
      sprintf(xyz, "Macro \"%s\" wasn't called with enough arguments.\n", macro_runtime_current->macro->name);
      print_error(xyz, ERROR_NUM);
    }
    return FAILED;
  }
 
  d = macro_runtime_current->argument_data[d - 1]->start;
 
  for (; k < MAX_NAME_LENGTH; d++, k++) {
    if (buffer[d] == 0 || buffer[d] == ' ' || buffer[d] == 0x0A || buffer[d] == ',')
      break;
    expanded_macro_string[k] = buffer[d];
  }
 
  for (; k < MAX_NAME_LENGTH; i++, k++) {
    expanded_macro_string[k] = in[i];
    if (in[i] == 0) {
      break;
    }
  }
 
  strcpy(t, expanded_macro_string);
  expand_macro_arguments(t, &d);
 
  return SUCCEEDED;
}

Line No.	Rev	Author	Line
1	178	jshamlet
2			`#include <ctype.h>`
3			`#include <stdio.h>`
4			`#include <stdlib.h>`
5			`#include <string.h>`
6
7			`#include "defines.h"`
8
9			`#include "parse.h"`
10			`#include "pass_1.h"`
11			`#include "stack.h"`
12
13
14			`int input_number_error_msg = YES, ss, string_size, input_float_mode = OFF, parse_floats = YES;`
15			`int newline_beginning = ON;`
16			`char label[MAX_NAME_LENGTH], xyz[256];`
17			`char unevaluated_expression[256];`
18			`char expanded_macro_string[256];`
19			`double flo;`
20
21			`extern int i, size, d, macro_active;`
22			`extern char *buffer, tmp[4096], cp[256];`
23			`extern struct active_file_info active_file_info_first, active_file_info_last, *active_file_info_tmp;`
24			`extern struct definition defines, tmp_def, *next_def;`
25			`extern struct macro_runtime *macro_runtime_current;`
26			`extern int latest_stack;`
27
28			`int operand_hint;`
29
30
31			`int compare_next_token(char *in, int s) {`
32
33			`int a, t, d, k;`
34			`char e;`
35
36
37			`a = i;`
38			`for (e = buffer[a]; e == ' ' \|\| e == ',' \|\| e == 0x0A; e = buffer[++a]);`
39
40			`/* MACRO mode? */`
41			`if (macro_active != 0 && e == '\\') {`
42			`for (d = 0, k = 0; k < 16; k++) {`
43			`e = buffer[++a];`
44			`if (e >= '0' && e <= '9')`
45			`d = (d * 10) + e - '0';`
46			`else`
47			`break;`
48			`}`
49
50			`if (d > macro_runtime_current->supplied_arguments) {`
51			`if (input_number_error_msg == YES) {`
52			`sprintf(xyz, "COMPARE_NEXT_SYMBOL: Macro \"%s\" wasn't called with enough arguments.\n", macro_runtime_current->macro->name);`
53			`print_error(xyz, ERROR_NONE);`
54			`}`
55			`return FAILED;`
56			`}`
57
58			`a = macro_runtime_current->argument_data[d - 1]->start;`
59
60			`e = buffer[a];`
61			`for (t = 0; t < s && e != ' ' && e != ',' && e != 0x0A; ) {`
62			`if (toupper(in[t]) != toupper(e))`
63			`return FAILED;`
64			`t++;`
65			`e = buffer[++a];`
66			`}`
67			`}`
68			`/* not in MACRO mode */`
69			`else {`
70			`for (t = 0; t < s && e != ' ' && e != ',' && e != 0x0A; ) {`
71			`if (toupper(in[t]) != toupper(e))`
72			`return FAILED;`
73			`t++;`
74			`e = buffer[++a];`
75			`}`
76			`}`
77
78			`if (t == s)`
79			`return SUCCEEDED;`
80			`else`
81			`return FAILED;`
82			`}`
83
84
85			`int input_next_string(void) {`
86
87			`char e;`
88			`int k, d;`
89
90
91			`for (e = buffer[i++]; e == ' ' \|\| e == ','; e = buffer[i++]);`
92
93			`if (e == 0x0A)`
94			`return INPUT_NUMBER_EOL;`
95
96			`/* last choice is a label */`
97			`tmp[0] = e;`
98			`for (k = 1; k < MAX_NAME_LENGTH - 1; k++) {`
99			`e = buffer[i++];`
100			`if (e == 0x0A \|\| e == ',') {`
101			`i--;`
102			`break;`
103			`}`
104			`else if (e == ' ')`
105			`break;`
106			`tmp[k] = e;`
107			`}`
108
109			`if (k == MAX_NAME_LENGTH - 1) {`
110			`if (input_number_error_msg == YES) {`
111			`sprintf(xyz, "The string is too long (max %d bytes).\n", MAX_NAME_LENGTH - 1);`
112			`print_error(xyz, ERROR_NUM);`
113			`}`
114			`return FAILED;`
115			`}`
116
117			`tmp[k] = 0;`
118
119			`/* expand eg. \1 and \@ */`
120			`if (macro_active != 0) {`
121			`d = 0;`
122			`if (expand_macro_arguments(tmp, &d) == FAILED)`
123			`return FAILED;`
124			`if (d != 0)`
125			`strcpy(tmp, expanded_macro_string);`
126			`}`
127
128			`return SUCCEEDED;`
129			`}`
130
131
132			`int input_number(void) {`
133
134			`unsigned char e, ee;`
135			`int k, p, q;`
136			`double dn;`
137
138
139			`operand_hint = HINT_NONE;`
140
141			`for (e = buffer[i++]; e == ' ' \|\| e == ','; e = buffer[i++]);`
142
143			`if (e == 0x0A)`
144			`return INPUT_NUMBER_EOL;`
145
146			`/* check the type of the expression */`
147			`p = i;`
148			`ee = e;`
149			`while (ee != 0x0A) {`
150			`/* string / symbol -> no calculating */`
151			`if (ee == '"' \|\| ee == ',' \|\| (ee == '=' && buffer[p] == '=') \|\|`
152			`(ee == '!' && buffer[p] == '='))`
153			`break;`
154			`if (ee == '-' \|\| ee == '+' \|\| ee == '*' \|\| ee == '/' \|\| ee == '&' \|\| ee == '\|' \|\| ee == '^' \|\|`
155			`ee == '<' \|\| ee == '>' \|\| ee == '#' \|\| ee == '~') {`
156			`/* launch stack calculator */`
157			`p = stack_calculate(&buffer[i - 1], &d);`
158			`if (p == STACK_CALCULATE_DELAY)`
159			`break;`
160			`else if (p == STACK_RETURN_LABEL)`
161			`return INPUT_NUMBER_ADDRESS_LABEL;`
162			`else`
163			`return p;`
164			`}`
165			`ee = buffer[p];`
166			`p++;`
167			`}`
168
169			`/* MACRO */`
170			`if (macro_active != 0 && e == '\\') {`
171
172			`struct macro_argument *ma;`
173
174
175			`if (buffer[i] == '@') {`
176			`i++;`
177			`d = macro_runtime_current->macro->calls - 1;`
178			`return SUCCEEDED;`
179			`}`
180
181			`for (d = 0, k = 0; k < 4; k++) {`
182			`e = buffer[i++];`
183			`if (e >= '0' && e <= '9')`
184			`d = (d * 10) + (e - '0');`
185			`else {`
186			`i--;`
187			`break;`
188			`}`
189			`}`
190
191			`if (d > macro_runtime_current->supplied_arguments) {`
192			`sprintf(xyz, "Referencing argument number %d inside macro \"%s\". The macro has only %d arguments.\n", d, macro_runtime_current->macro->name, macro_runtime_current->supplied_arguments);`
193			`print_error(xyz, ERROR_NUM);`
194			`return FAILED;`
195			`}`
196
197			`/* return the macro argument */`
198			`ma = macro_runtime_current->argument_data[d - 1];`
199			`k = ma->type;`
200
201			`if (k == INPUT_NUMBER_ADDRESS_LABEL)`
202			`strcpy(label, ma->string);`
203			`else if (k == INPUT_NUMBER_STRING) {`
204			`strcpy(label, ma->string);`
205			`string_size = strlen(ma->string);`
206			`}`
207			`else if (k == INPUT_NUMBER_STACK)`
208			`latest_stack = ma->value;`
209			`else if (k == SUCCEEDED)`
210			`d = ma->value;`
211			`else {`
212			`print_error("Macro argument list has been corrupted! Please send a bug report!\n", ERROR_ERR);`
213			`return FAILED;`
214			`}`
215
216			`return k;`
217			`}`
218
219			`/* is it a hexadecimal value? */`
220			`d = 0;`
221			`if (e >= '0' && e <= '9') {`
222			`for (k = 0; 1; k++) {`
223			`if (buffer[i+k] >= '0' && buffer[i+k] <= '9')`
224			`continue;`
225			`if (buffer[i+k] >= 'a' && buffer[i+k] <= 'f')`
226			`continue;`
227			`if (buffer[i+k] >= 'A' && buffer[i+k] <= 'F')`
228			`continue;`
229			`if (buffer[i+k] == 'h' \|\| buffer[i+k] == 'H') {`
230			`d = 1;`
231			`break;`
232			`}`
233			`break;`
234			`}`
235			`}`
236
237			`if (e == '$' \|\| d == 1) {`
238			`if (d == 1)`
239			`i--;`
240			`for (d = 0, k = 0; k < 8; k++, i++) {`
241			`e = buffer[i];`
242			`if (e >= '0' && e <= '9')`
243			`d = (d << 4) + e - '0';`
244			`else if (e >= 'A' && e <= 'F')`
245			`d = (d << 4) + e - 'A' + 10;`
246			`else if (e >= 'a' && e <= 'f')`
247			`d = (d << 4) + e - 'a' + 10;`
248			`else if (e == 'h' \|\| e == 'H') {`
249			`i++;`
250			`e = buffer[i];`
251			`break;`
252			`}`
253			`else`
254			`break;`
255			`}`
256
257			`if (e == '.') {`
258			`e = buffer[i+1];`
259			`if (e == 'b' \|\| e == 'B') {`
260			`operand_hint = HINT_8BIT;`
261			`i += 2;`
262			`}`
263			`else if (e == 'w' \|\| e == 'W') {`
264			`operand_hint = HINT_16BIT;`
265			`i += 2;`
266			`}`
267			`}`
268
269			`return SUCCEEDED;`
270			`}`
271
272			`if (e >= '0' && e <= '9') {`
273			`q = 0;`
274			`flo = e-'0';`
275			`dn = 0.1;`
276			`for (k = 0; k < 9; k++, i++) {`
277			`e = buffer[i];`
278			`if (e >= '0' && e <= '9') {`
279			`if (q == 0) {`
280			`/* still parsing an integer */`
281			`flo = flo*10 + e-'0';`
282			`}`
283			`else {`
284			`flo = flo + dn*(e-'0');`
285			`dn /= 10.0;`
286			`}`
287			`}`
288			`else if (e == '.') {`
289			`if (q == 1) {`
290			`print_error("Syntax error.\n", ERROR_NUM);`
291			`return FAILED;`
292			`}`
293			`e = buffer[i+1];`
294			`if (e >= '0' && e <= '9') {`
295			`/* float mode, read decimals */`
296			`if (parse_floats == NO)`
297			`break;`
298			`q = 1;`
299			`}`
300			`else if (e == 'b' \|\| e == 'B') {`
301			`operand_hint = HINT_8BIT;`
302			`i += 2;`
303			`break;`
304			`}`
305			`else if (e == 'w' \|\| e == 'W') {`
306			`operand_hint = HINT_16BIT;`
307			`i += 2;`
308			`break;`
309			`}`
310			`}`
311			`else`
312			`break;`
313			`}`
314
315			`/* drop the decimals */`
316			`d = flo;`
317
318			`if (q == 1 && input_float_mode == ON)`
319			`return INPUT_NUMBER_FLOAT;`
320
321			`return SUCCEEDED;`
322			`}`
323
324			`if (e == '%') {`
325			`for (d = 0, k = 0; k < 32; k++, i++) {`
326			`e = buffer[i];`
327			`if (e == '0' \|\| e == '1')`
328			`d = (d << 1) + e - '0';`
329			`else`
330			`break;`
331			`}`
332
333			`if (e == '.') {`
334			`e = buffer[i+1];`
335			`if (e == 'b' \|\| e == 'B') {`
336			`operand_hint = HINT_8BIT;`
337			`i += 2;`
338			`}`
339			`else if (e == 'w' \|\| e == 'W') {`
340			`operand_hint = HINT_16BIT;`
341			`i += 2;`
342			`}`
343			`}`
344
345			`return SUCCEEDED;`
346			`}`
347
348			`if (e == '\'') {`
349			`d = buffer[i++];`
350			`e = buffer[i];`
351			`if (e != '\'') {`
352			`if (input_number_error_msg == YES) {`
353			`sprintf(xyz, "Got '%c' (%d) when expected \"'\".\n", e, e);`
354			`print_error(xyz, ERROR_NUM);`
355			`}`
356			`return FAILED;`
357			`}`
358			`i++;`
359
360			`return SUCCEEDED;`
361			`}`
362
363			`if (e == '"') {`
364
365			`for (k = 0; k < MAX_NAME_LENGTH - 1; ) {`
366			`e = buffer[i++];`
367
368			`if (e == '\\' && buffer[i] == '"') {`
369			`label[k++] = '"';`
370			`i++;`
371			`continue;`
372			`}`
373
374			`if (e == '"')`
375			`break;`
376
377			`if (e == 0 \|\| e == 0x0A) {`
378			`print_error("String wasn't terminated properly.\n", ERROR_NUM);`
379			`return FAILED;`
380			`}`
381
382			`label[k++] = e;`
383			`}`
384
385			`label[k] = 0;`
386
387			`/* expand eg. \1 and \@ */`
388			`if (macro_active != 0) {`
389			`d = 0;`
390			`if (expand_macro_arguments(label, &d) == FAILED)`
391			`return FAILED;`
392			`if (d != 0) {`
393			`strcpy(label, expanded_macro_string);`
394			`k = strlen(label);`
395			`}`
396			`}`
397
398			`if (k == MAX_NAME_LENGTH - 1) {`
399			`if (input_number_error_msg == YES) {`
400			`sprintf(xyz, "The string is too long (max %d bytes).\n", MAX_NAME_LENGTH - 1);`
401			`print_error(xyz, ERROR_NUM);`
402			`}`
403			`return FAILED;`
404			`}`
405
406			`label[k] = 0;`
407			`string_size = k;`
408			`return INPUT_NUMBER_STRING;`
409			`}`
410
411			`/* last choice is a label */`
412			`label[0] = e;`
413			`for (k = 1; k < MAX_NAME_LENGTH - 1; k++) {`
414			`e = buffer[i++];`
415			`if (e == 0x0A \|\| e == ')' \|\| e == ',' \|\| e == ']') {`
416			`i--;`
417			`break;`
418			`}`
419			`else if (e == ' ')`
420			`break;`
421			`label[k] = e;`
422			`}`
423
424			`if (k == MAX_NAME_LENGTH - 1) {`
425			`if (input_number_error_msg == YES) {`
426			`sprintf(xyz, "The label is too long (max %d bytes).\n", MAX_NAME_LENGTH - 1);`
427			`print_error(xyz, ERROR_NUM);`
428			`}`
429			`return FAILED;`
430			`}`
431
432			`/* size hint? */`
433			`if (label[k-2] == '.') {`
434			`if (label[k-1] == 'b' \|\| label[k-1] == 'B') {`
435			`operand_hint = HINT_8BIT;`
436			`k -= 2;`
437			`}`
438			`else if (label[k-1] == 'w' \|\| label[k-1] == 'W') {`
439			`operand_hint = HINT_16BIT;`
440			`k -= 2;`
441			`}`
442			`}`
443
444			`label[k] = 0;`
445
446			`/* expand eg. \1 and \@ */`
447			`if (macro_active != 0) {`
448			`d = 0;`
449			`if (expand_macro_arguments(label, &d) == FAILED)`
450			`return FAILED;`
451			`if (d != 0)`
452			`strcpy(label, expanded_macro_string);`
453			`}`
454
455			`/* check if the label is actually a definition */`
456			`tmp_def = defines;`
457			`while (tmp_def != NULL) {`
458			`if (strcmp(label, tmp_def->alias) == 0) {`
459			`if (tmp_def->type == DEFINITION_TYPE_VALUE) {`
460			`d = tmp_def->value;`
461			`return SUCCEEDED;`
462			`}`
463			`else if (tmp_def->type == DEFINITION_TYPE_STACK) {`
464			`/* skip stack definitions -> use its name instead */`
465			`}`
466			`else {`
467			`string_size = tmp_def->size;`
468			`memcpy(label, tmp_def->string, string_size);`
469			`label[string_size] = 0;`
470			`return INPUT_NUMBER_STRING;`
471			`}`
472			`}`
473			`tmp_def = tmp_def->next;`
474			`}`
475
476			`return INPUT_NUMBER_ADDRESS_LABEL;`
477			`}`
478
479
480			`int get_next_token(void) {`
481
482			`int q;`
483
484
485			`while (1) {`
486			`if (i == size)`
487			`break;`
488			`if (buffer[i] == ' ') {`
489			`i++;`
490			`newline_beginning = OFF;`
491			`continue;`
492			`}`
493			`if (buffer[i] == 0x0A) {`
494			`i++;`
495			`next_line();`
496			`continue;`
497			`}`
498			`break;`
499			`}`
500
501			`if (buffer[i] == '"') {`
502			`for (ss = 0, i++; buffer[i] != 0x0A && buffer[i] != '"'; ) {`
503			`if (buffer[i] == '\\' && buffer[i + 1] == '"') {`
504			`tmp[ss++] = '"';`
505			`i += 2;`
506			`}`
507			`else`
508			`tmp[ss++] = buffer[i++];`
509			`}`
510
511			`if (buffer[i] == 0x0A) {`
512			`print_error("GET_NEXT_TOKEN: String wasn't terminated properly.\n", ERROR_NONE);`
513			`return FAILED;`
514			`}`
515			`tmp[ss] = 0;`
516			`i++;`
517
518			`/* expand eg. \1 and \@ */`
519			`if (macro_active != 0) {`
520			`q = 0;`
521			`if (expand_macro_arguments(tmp, &q) == FAILED)`
522			`return FAILED;`
523			`if (q != 0) {`
524			`strcpy(tmp, expanded_macro_string);`
525			`ss = strlen(tmp);`
526			`}`
527			`}`
528
529			`return GET_NEXT_TOKEN_STRING;`
530			`}`
531
532			`if (buffer[i] == '.') {`
533			`tmp[0] = '.';`
534			`i++;`
535			`for (ss = 1; buffer[i] != 0x0A && buffer[i] != ' ' && ss <= MAX_NAME_LENGTH; ) {`
536			`tmp[ss] = buffer[i];`
537			`cp[ss - 1] = toupper((int)buffer[i]);`
538			`i++;`
539			`ss++;`
540			`}`
541			`cp[ss - 1] = 0;`
542			`}`
543			`else if (buffer[i] == '=' \|\| buffer[i] == '>' \|\| buffer[i] == '<' \|\| buffer[i] == '!') {`
544			`for (ss = 0; buffer[i] != 0x0A && (buffer[i] == '=' \|\| buffer[i] == '!' \|\| buffer[i] == '<' \|\| buffer[i] == '>')`
545			`&& ss <= MAX_NAME_LENGTH; tmp[ss++] = buffer[i++]);`
546			`}`
547			`else {`
548			`for (ss = 0; buffer[i] != 0x0A && buffer[i] != ',' && buffer[i] != ' ' && ss <= MAX_NAME_LENGTH; ) {`
549			`tmp[ss] = buffer[i];`
550			`ss++;`
551			`i++;`
552			`}`
553			`if (buffer[i] == ',')`
554			`i++;`
555			`}`
556
557			`if (ss > MAX_NAME_LENGTH) {`
558			`print_error("GET_NEXT_TOKEN: Too long for a token.\n", ERROR_NONE);`
559			`return FAILED;`
560			`}`
561
562			`tmp[ss] = 0;`
563
564			`/* expand eg. \1 and \@ */`
565			`if (macro_active != 0) {`
566			`q = 0;`
567			`if (expand_macro_arguments(tmp, &q) == FAILED)`
568			`return FAILED;`
569			`if (q != 0) {`
570			`strcpy(tmp, expanded_macro_string);`
571			`ss = strlen(tmp);`
572			`}`
573			`}`
574
575			`return SUCCEEDED;`
576			`}`
577
578
579			`int skip_next_token(void) {`
580
581			`for (; buffer[i] == ' ' \|\| buffer[i] == ','; i++);`
582
583			`if (buffer[i] == 0x0A)`
584			`return FAILED;`
585
586			`if (buffer[i] == '"') {`
587			`for (i++; buffer[i] != 0x0A && buffer[i] != '"'; i++);`
588			`if (buffer[i] == 0x0A) {`
589			`print_error("SKIP_NEXT_TOKEN: String wasn't terminated properly.\n", ERROR_NONE);`
590			`return FAILED;`
591			`}`
592			`i++;`
593
594			`return SUCCEEDED;`
595			`}`
596
597			`for (; buffer[i] != 0x0A && buffer[i] != ' ' && buffer[i] != ','; i++);`
598
599			`return SUCCEEDED;`
600			`}`
601
602
603			`int expand_macro_arguments(char in, int s) {`
604
605			`char t[256];`
606			`int i, k, d;`
607
608
609			`for (i = 0; i < MAX_NAME_LENGTH; i++) {`
610			`if (in[i] == '\\') {`
611			`if (in[i + 1] == '"' \|\| in[i + 1] == 'n' \|\| in[i + 1] == '\\') {`
612			`expanded_macro_string[i] = in[i];`
613			`i++;`
614			`expanded_macro_string[i] = in[i];`
615			`continue;`
616			`}`
617			`break;`
618			`}`
619			`expanded_macro_string[i] = in[i];`
620			`if (in[i] == 0)`
621			`return SUCCEEDED;`
622			`}`
623
624			`k = i;`
625			`i++;`
626
627			`(*s)++;`
628
629			`if (in[i] == '@') {`
630			`i++;`
631			`sprintf(&expanded_macro_string[k], "%d%c", macro_runtime_current->macro->calls - 1, 0);`
632			`k = strlen(expanded_macro_string);`
633
634			`for (; i < MAX_NAME_LENGTH; i++, k++) {`
635			`expanded_macro_string[k] = in[i];`
636			`if (in[i] == 0) {`
637			`break;`
638			`}`
639			`}`
640
641			`strcpy(t, expanded_macro_string);`
642			`expand_macro_arguments(t, &d);`
643			`return SUCCEEDED;`
644			`}`
645
646			`if (in[i] <= '0' \|\| in[i] >= '9') {`
647			`if (input_number_error_msg == YES) {`
648			`sprintf(xyz, "EXPAND_MACRO_ARGUMENTS: Unsupported special character '%c'.\n", in[i]);`
649			`print_error(xyz, ERROR_NUM);`
650			`}`
651			`return FAILED;`
652			`}`
653
654			`for (d = 0; in[i] != 0; i++) {`
655			`if (in[i] >= '0' && in[i] <= '9')`
656			`d = (d * 10) + in[i] - '0';`
657			`else`
658			`break;`
659			`}`
660
661			`if (d > macro_runtime_current->supplied_arguments) {`
662			`if (input_number_error_msg == YES) {`
663			`sprintf(xyz, "Macro \"%s\" wasn't called with enough arguments.\n", macro_runtime_current->macro->name);`
664			`print_error(xyz, ERROR_NUM);`
665			`}`
666			`return FAILED;`
667			`}`
668
669			`d = macro_runtime_current->argument_data[d - 1]->start;`
670
671			`for (; k < MAX_NAME_LENGTH; d++, k++) {`
672			`if (buffer[d] == 0 \|\| buffer[d] == ' ' \|\| buffer[d] == 0x0A \|\| buffer[d] == ',')`
673			`break;`
674			`expanded_macro_string[k] = buffer[d];`
675			`}`
676
677			`for (; k < MAX_NAME_LENGTH; i++, k++) {`
678			`expanded_macro_string[k] = in[i];`
679			`if (in[i] == 0) {`
680			`break;`
681			`}`
682			`}`
683
684			`strcpy(t, expanded_macro_string);`
685			`expand_macro_arguments(t, &d);`
686
687			`return SUCCEEDED;`
688			`}`

Browse

Tools

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [Open8 Tools/] [open8_src/] [open8_as/] [parse.c] - Blame information for rev 289