fparse.y

Solaris操作系统下的过滤驱动程序, C源码程序.

		| ADDMK_LIST SEMICOLON
		{
		  char *cp;
		  if (parsedebug)
		    fprintf(stderr, "add_mk: %s\n", $1);

		  cp = strtok($1, " \t");
		  while (cp) {
		    if (!fist_validate_decl_addmk(cp, errmsg)) {
		      yyerror(errmsg);
		      YYABORT;
		    }
		    cp = strtok(NULL, " \t");
		  }
		}
		;

basic_data_types: basic_data_type
		| basic_data_type basic_data_types
		;

basic_data_type	: WORD WORD SEMICOLON
		{
		  if (parsedebug)
		    fprintf(stderr, "BDT: %s %s\n", $1, $2);
		  sprintf(buf, "\t%s %s;\n", $1, $2);
		  if (!append_to_bdt(&tmp_bdt, buf, $2)) {
		    yyerror("duplicate basic-data-type symbol");
		    YYABORT;
		  }
		}
		| WORD WORD WORD SEMICOLON
		{
		  if (parsedebug)
		    fprintf(stderr, "BDT: %s %s %s\n", $1, $2, $3);
		  sprintf(buf, "\t%s %s %s;\n", $1, $2, $3);
		  if (!append_to_bdt(&tmp_bdt, buf, $3)) {
		    yyerror("duplicate basic-data-type symbol");
		    YYABORT;
		  }
		}
		| WORD WORD LEFT_BRACKET NUMBER RIGHT_BRACKET SEMICOLON
		{
		  if (parsedebug)
		    fprintf(stderr, "BDT: %s %s [%d]\n", $1, $2, $4);
		  sprintf(buf, "\t%s %s [%d];\n", $1, $2, $4);
		  if (!append_to_bdt(&tmp_bdt, buf, $2)) {
		    yyerror("duplicate basic-data-type symbol");
		    YYABORT;
		  }
		}
		| WORD WORD LEFT_BRACKET WORD RIGHT_BRACKET SEMICOLON
		{
		  if (parsedebug)
		    fprintf(stderr, "BDT: %s %s [%s]\n", $1, $2, $4);
		  sprintf(buf, "\t%s %s [%s];\n", $1, $2, $4);
		  if (!append_to_bdt(&tmp_bdt, buf, $2)) {
		    yyerror("duplicate basic-data-type symbol");
		    YYABORT;
		  }
		}
		| WORD WORD WORD LEFT_BRACKET NUMBER RIGHT_BRACKET SEMICOLON
		{
		  if (parsedebug)
		    fprintf(stderr, "BDT: %s %s %s [%d]\n", $1, $2, $3, $5);
		  sprintf(buf, "\t%s %s %s [%d];\n", $1, $2, $3, $5);
		  if (!append_to_bdt(&tmp_bdt, buf, $3)) {
		    yyerror("duplicate basic-data-type symbol");
		    YYABORT;
		  }
		}
		| WORD WORD WORD LEFT_BRACKET WORD RIGHT_BRACKET SEMICOLON
		{
		  if (parsedebug)
		    fprintf(stderr, "BDT: %s %s %s [%s]\n", $1, $2, $3, $5);
		  sprintf(buf, "\t%s %s %s [%s];\n", $1, $2, $3, $5);
		  if (!append_to_bdt(&tmp_bdt, buf, $3)) {
		    yyerror("duplicate basic-data-type symbol");
		    YYABORT;
		  }
		}
		;

/****************************************************************************/

fist_rules_sect	: DOUBLE_PCT fist_rules
		| DOUBLE_PCT /* can be without any rules */
		;

fist_rules	: fist_rule
		| fist_rule fist_rules
		;

fist_rule	: FIST_RULE_DEF LEFT_BRACE statement_list RIGHT_BRACE
		{
		  if (parsedebug)
		    fprintf(stderr, "FIST_RULE_DEF: %s\n", $1);
		  if (!fist_validate_rule_def($1, errmsg, &tmp_ecl)) {
		    yyerror(errmsg);
		    YYABORT;
		  }
		}
		;

statement_list	: statement
		| statement statement_list
		;

statement	: compound_statement
		| single_item
		;

compound_statement : LEFT_BRACE statement_list RIGHT_BRACE
		| LEFT_BRACE RIGHT_BRACE
		;

single_item	: fist_var
		| fist_fxn
		| SEMICOLON
		;

/*
fist_vars_or_fxns : fist_var_or_fxn
		| fist_var_or_fxn fist_vars_or_fxns
		;

fist_var_or_fxn : fist_var
		| fist_fxn
		;
*/

/****************************************************************************/
opt_code_sect	: DOUBLE_PCT opt_code_lines
		| DOUBLE_PCT /* no actual lines */
		| /* can be empty: no %% or code lines */
		;

opt_code_lines	: opt_code_line
		| opt_code_line opt_code_lines
		;

opt_code_line	: fist_var
		| fist_fxn
		;

/****************************************************************************/
/*** GENERIC RULES FOR A FiST VARIABLE */
fist_var	: PCT_ALPHA
		{
		  if (parsedebug)
		    fprintf(stderr, "pct_alpha = \"%s\"\n", $1);
		  if (fist_validate_global_variable($1)) {
		    fyy_echo(expand_pct_var($1));
		  } else {
		    yyerror("unknown FiST global variable");
		    YYABORT;
		  }
		}
		| DOLLAR_VNA
		{
		  if (parsedebug)
		    fprintf(stderr, "dollar_vna = \"%s\"\n", $1);
		  strcpy(buf, $1);
		  dv = dn = da = NULL;
		  da = strchr(buf, '.');
		  if (da)
		    *da++ = '\0';
		  dn = strchr(buf, ':');
		  if (dn)
		    *dn++ = '\0';
		  dv = strchr(buf, '$');
		  if (dv)
		    *dv++ = '\0';
		  if (fist_validate_dollar_variable($1, dv, dn, da, errmsg)) {
		    fyy_echo(expand_dollar_var($1, dv, dn, da));
		  } else {
		    yyerror(errmsg);
		    YYABORT;
		  }
		}
		| DOLLAR_VN
		{
		  if (parsedebug)
		    fprintf(stderr, "dollar_vn = \"%s\"\n", $1);
		  strcpy(buf, $1);
		  dv = dn = da = NULL;
		  dn = strchr(buf, ':');
		  if (dn)
		    *dn++ = '\0';
		  dv = strchr(buf, '$');
		  if (dv)
		    *dv++ = '\0';
		  if (fist_validate_dollar_variable($1, dv, dn, da, errmsg)) {
		    fyy_echo(expand_dollar_var($1, dv, dn, da));
		  } else {
		    yyerror(errmsg);
		    YYABORT;
		  }
		}
		| DOLLAR_NA
		{
		  if (parsedebug)
		    fprintf(stderr, "dollar_na = \"%s\"\n", $1);
		  strcpy(buf, $1);
		  dv = dn = da = NULL;
		  da = strchr(buf, '.');
		  if (da)
		    *da++ = '\0';
		  dn = strchr(buf, '$');
		  if (dn)
		    *dn++ = '\0';
		  if (fist_validate_dollar_variable($1, dv, dn, da, errmsg)) {
		    fyy_echo(expand_dollar_var($1, dv, dn, da));
		  } else {
		    yyerror(errmsg);
		    YYABORT;
		  }
		}
		| DOLLAR_VA
		{
		  if (parsedebug)
		    fprintf(stderr, "dollar_va = \"%s\"\n", $1);
		  strcpy(buf, $1);
		  dv = dn = da = NULL;
		  da = strchr(buf, '.');
		  if (da)
		    *da++ = '\0';
		  dv = strchr(buf, '$');
		  if (dv)
		    *dv++ = '\0';
		  if (fist_validate_dollar_variable($1, dv, dn, da, errmsg)) {
		    fyy_echo(expand_dollar_var($1, dv, dn, da));
		  } else {
		    yyerror(errmsg);
		    YYABORT;
		  }
		}
		| DOLLAR_V
		{
		  if (parsedebug)
		    fprintf(stderr, "dollar_v = \"%s\"\n", $1);
		  strcpy(buf, $1);
		  dv = dn = da = NULL;
		  dv = strchr(buf, '$');
		  if (dv)
		    *dv++ = '\0';
		  if (fist_validate_dollar_variable($1, dv, dn, da, errmsg)) {
		    fyy_echo(expand_dollar_var($1, dv, dn, da));
		  } else {
		    yyerror(errmsg);
		    YYABORT;
		  }
		}
		| DOLLAR_N
		{
		  if (parsedebug)
		    fprintf(stderr, "dollar_n = \"%s\"\n", $1);
		  strcpy(buf, $1);
		  dv = dn = da = NULL;
		  dn = strchr(buf, '$');
		  if (dn)
		    *dn++ = '\0';
		  if (fist_validate_dollar_variable($1, dv, dn, da, errmsg)) {
		    fyy_echo(expand_dollar_var($1, dv, dn, da));
		  } else {
		    yyerror(errmsg);
		    YYABORT;
		  }
		}
		;

/****************************************************************************/
/*** GENERIC RULES FOR A FiST FUNCTION */

fist_fxn	: FIST_FXN LEFT_PAREN RIGHT_PAREN
		{
		  if (parsedebug)
		    fprintf(stderr, "fist_fxn (no args): %s\n", $1);
		  parsing_fist_fxn = FALSE; /* so fyy_echo will ecl_strcat */
		  if (expand_fist_fxn(fxnbuf, $1, 0, NULL)) {
		    fyy_echo(fxnbuf);
		  } else {
		    yyerror(fxnbuf);
		    YYABORT;
		  }
		}
		| FIST_FXN LEFT_PAREN func_args RIGHT_PAREN
		{
		  if (parsedebug) {
		    int i;
		    fprintf(stderr, "fist_fxn (with %d args): %s\n",
			    num_func_args, $1);
		    for (i=0; i<num_func_args; i++) {
		      fprintf(stderr, "\tfunc_arg %d = \"%s\"\n",
			      i+1, func_args[i]);
		    }
		  }
		  parsing_fist_fxn = FALSE; /* so fyy_echo will ecl_strcat */
		  if (expand_fist_fxn(fxnbuf, $1, num_func_args, func_args)) {
		    fyy_echo(fxnbuf);
		  } else {
		    yyerror(fxnbuf);
		    YYABORT;
		  }
		}
		;

func_args	: func_arg
		| func_arg func_args
		;

func_arg	: FUNCARG
		{
		  if (parsedebug)
		    fprintf(stderr, "func_arg0: %s\n", $1);
		  add_func_arg($1);
		}
		| fist_var
		;

/****************************************************************************/

%%

static int
yyerror(const char *s)
{
  fprintf(stderr, "%s:%d: %s\n", in_file, yylineno, s);
  exit(1);
  return 1;	/* to fool compilers that insist on a return statement */
}

static void
fyy_echo(const char *s)
{
  if (parsing_fist_rules) {
    if (parsing_fist_fxn)
      add_func_arg(s);
    else
      ecl_strcat(tmp_ecl, s);
  } else {
    fprintf(out_fp_c, "%s", s);
  }
}

static void
add_func_arg(const char *s)
{
  if (!parsing_fist_fxn)
    yyerror("not parsing a fist function!");
  if (num_func_args >= MAX_FUNCARGS)
    yyerror("exceeded maximum number of fist function arguments");
  func_args[num_func_args++] = strdup(s);
}