CEDET

I haven't gotten rid of that shift-reduce conflict, though I am
using %left EQ, %left NEQ (against the request of the spec, see
previous email).  But my current question is about something else:
expanding blocks.  I think I am just getting the hang of the TAG
system -- but tags or no tags, I'm still confused by the EXPAND
macros.

The basic problem I want to deal with are lists of things like

   (a, b, c)    [1 ; 2 ; 3]   {int, bool}

or whatever you like.   With my current set up (copied below),
the example

   (1, 2, 3)

gets parsed as

(("number" expr
  (:value "1")
  nil #<overlay from 17 to 18 in example.simple>)
 ("number" expr
  (:value "2")
  nil #<overlay from 21 to 22 in example.simple>)
 ("number" expr
  (:value "3")
  nil #<overlay from 24 to 25 in example.simple>))

But I would like some extra structure to represent the fact that
these numbers are part of a parenthesized list!  Currently that fact
seems to be being ignored by wisent.

The rule that is relevant here is

  | PAREN_BLOCK
    (format "printme %s" (EXPANDFULL $1 expr_seq))

Probably this is not the right way to get things to happen with the
expansion of the paren block.  Can you tell me what I should be
doing instead?

;;; simple.wy -- LALR grammar for (simplified) Tiger

%package simple-wy

;; Not really necessary, as it is the default start symbol
%start expr
%start function_parameters
%start expr_seq

%type  <punctuation>
%token <punctuation> COMMA                    ","

%type  <symbol>
%token <symbol> symbol "[A-Za-z][_A-Za-z0-9]*"

%type  <string>
%token <string> STRING_LITERAL

%type  <number>
%token <number> NUMBER_LITERAL

%type  <keyword>
%keyword NEQ                     "<>"
%keyword EQ                      "="

%left EQ
%left NEQ

%type  <open-paren>
%token <open-paren>  LPAREN      "("

%type  <close-paren>
%token <close-paren> RPAREN      ")"

%type  <block>
%token <block> PAREN_BLOCK "(LPAREN RPAREN)"

%%

;; For use with Semantic, must return valid semantic tags!
expr
  : STRING_LITERAL
    (TAG "string" 'expr :value $1)
  | NUMBER_LITERAL
    (TAG "number" 'expr :value $1)
  | expr EQ expr
    (TAG "expr eq" 'expr :value (format "(equal %s %s)"
                                        (value-of $1)
                                        (value-of $3)))
  | expr NEQ expr
    (TAG "expr eq" 'expr :value (format "(not (equal %s %s))" 
                                        (value-of $1)
                                        (value-of $3)))
  | PAREN_BLOCK
    (format "printme %s" (EXPANDFULL $1 expr_seq))
  ;

expr_seq
  : LPAREN
    ()
  | RPAREN
    ()
  | expr COMMA function_parameters
    (concat $1 (EXPANDFULL $3 function_parameters))
  | expr RPAREN
    (concat $1)
  ;

;; parameters: '(' [varargslist] ')'
function_parameters
  : LPAREN
    ()
  | RPAREN
    ()
  | expr COMMA function_parameters
    (TAG "function_parameter" 'function_parameter 
         :value
         (concat 
         $1
         (EXPANDFULL $3 function_parameters)))
  | expr RPAREN
    (TAG "function_parameter" 'function_parameter :value $1)
  ;

%%

(define-lex simple-lexer
  "Simple lexical analyzer."
  semantic-lex-ignore-whitespace
  semantic-lex-ignore-newline
  semantic-lex-ignore-comments
  ;;;; Auto-generated analyzers.
  simple-wy--<block>-block-analyzer
  simple-wy--<keyword>-keyword-analyzer
  simple-wy--<punctuation>-string-analyzer
  simple-wy--<number>-regexp-analyzer
  ;; From the documentation string for `semantic-lex-tokens':
  ;; "Always add this analyzer *after* `semantic-lex-number', or other
  ;; analyzers that match its regular expression." (my emphasis)
  simple-wy--<symbol>-regexp-analyzer
  simple-wy--<string>-sexp-analyzer
  ;;;;
  semantic-lex-default-action)

;;; simple.wy ends here


;;; simple-mode.el -- major mode for a simple language

;;; Semantic parsing support

(require 'semantic-wisent)
(require 'simple-wy)

;;;###autoload
(defun semantic-default-simple-setup ()
  "Set up a buffer for semantic parsing of a SIMPLE language."
  ;; Do some useful things.
  (setq semantic-ignore-comments t)
  ;; Install the parser
  (simple-wy--install-parser)
  ;; Setup the lexer
  (setq semantic-lex-analyzer 'simple-lexer
        ;; Do a full depth lexical analysis.
        semantic-lex-depth nil))

;;;###autoload
(add-hook 'simple-mode-hook 'semantic-default-simple-setup)

(defun value-of (tok)
  (car
   (cdaddr tok)))

;;; post parser processing

(defun clean-up-parser-output ()
  (interactive)
  (set-buffer (get-buffer "*Parser Output*"))
  (flush-lines "overlay")
  (flush-lines "expr")
;;  (flush-lines "\"expr\" expr")
  (goto-char (point-min))
  (replace-regexp "  (:value \"\\|\")$" "")
  (goto-char (point-min))
  (replace-regexp "\\\\\"" "\""))

(defun novinate ()
  (interactive)
  (bovinate)
  (clean-up-parser-output)
  (other-window 1))

;;; simple major mode

(defvar simple-mode-syntax-table
  (let ((table (make-syntax-table (standard-syntax-table))))
    (modify-syntax-entry ?\+ "."     table) ;; Operator PLUS
    (modify-syntax-entry ?\- "."     table) ;; Operator MINUS
    ;; also deals with comments
    (modify-syntax-entry ?\* ". 23"  table) ;; Operator MULT
    (modify-syntax-entry ?\/ ". 14"  table) ;; Operator DIV
    ;; deal with brackets
    (modify-syntax-entry ?\( "()"    table)
    (modify-syntax-entry ?\{ "(}"    table)
    (modify-syntax-entry ?\[ "(]"    table)
    (modify-syntax-entry ?\) ")("    table)
    (modify-syntax-entry ?\} "){"    table)
    (modify-syntax-entry ?\] ")["    table)
    table)
  "Syntax table used in simple mode buffers.
Define operators as punctuations.")

;;;###autoload
(define-derived-mode simple-mode fundamental-mode "simple"
  (setq comment-start-skip "/\\*+ *"))

;;;###autoload
(add-to-list 'auto-mode-alist '("\\.simple\\'" . simple-mode))

;(defvar simple-mode-hook nil)

(provide 'simple-mode)

;;; simple-mode.el ends here