DouKaku?

(define (pick string)
  (cond
   ((#/([a-zA-Z]+)(-hidden)?(?:-(small|big))?\.([a-zA-Z]+)/ string)
    => (lambda (m)
         (print "name: '"(m 1)"', ext: '"(m 4)"', size: "(or (m 3) "normal")
                ", hidden: "(if (m 2)"True" "False"))
         (pick (m'after))))))

import re

def extract(s):
    for m in re.finditer('([a-zA-Z]+)(-hidden)?(?:-(big|small))?\.([a-zA-Z]+)', s):
        print "name:%r, ext:%r, size: %s hidden: %r" % \
            (m.group(1), m.group(4), m.group(3) or "normal", bool(m.group(2)))

def main():
    extract("""\
aaa abc-hidden.png>hoge-big.jpeg
---foo-hidden-small.gif|^_^a.bmp
--hiddena-hoge.png<=not hidden~~
--small.jpg<=not small(^_^)
normal-small-big.hoge""")

if __name__ == '__main__':
    main()

import java.util.regex.*;
import java.util.*;

public class Sample {
    private static final Pattern FILE_NAME_PATTERN = Pattern.
        compile("¥¥b(¥¥p{Alpha}+)((¥¥-¥¥p{Alpha}+)*)¥¥.(¥¥p{Alpha}+)¥¥b");
    public static void filter(String in) {
        Matcher m = FILE_NAME_PATTERN.matcher(in);
        while (m.find()) {
            Set<String> attrSet= new HashSet<String>(Arrays.asList(m.group(2).
                                                            split("¥¥-")));
            String size = "normal";
            if (attrSet.contains("big")) {
                size = "big";
            } else if (attrSet.contains("small")) {
                size = "small";
            }
            System.out.printf("name:'%s', ext:'%s', size: %s, hidden %b%n",
                m.group(1), m.group(4), size, attrSet.contains("hidden"));
        }
    }

    public static void main(String[] args) {
        filter("aaa abc-hidden.png>hoge-big.jpeg¥n" +
               "---foo-hidden-small.gif|^_^a.bmp¥n" +
               "--hiddena-hoge.png<=not hidden‾‾¥n" +
               "--small.jpg<=not small(^_^)¥n" +
               "normal-small-big.hoge¥n");
    }
}

def print_image_spec(str)
  str.scan(/([A-Za-z]+)(-hidden)?(?:-(small|big))?\.([A-Za-z]+)/) do |name, hidden, size, ext|
    printf("name:'%s', ext:'%s', size: %s hidden: %s\n",
      name, ext, size||'normal', hidden ? 'True' : 'False')
  end
end

function doukaku51($){
  var r = [];
  $.replace(/([a-z]+)(-hidden)?(?:-(big|small))?\.([a-z]+)/gi, function(_, n, h, s, e){
    r[r.length] = { name: n, ext: e, size: s || 'normal', hidden: !!h };
  });
  return r;
}
(this.WSH ? function($){WSH.echo($)} : alert)((function(a){
  for(var i = a.length, k, t; t = [], i--;){
    for(k in a[i]) t[t.length] = k +': '+ a[i][k];
    a[i] = t.join(',  ');
  }
  return a.join('\n');
})(doukaku51('aaa abc-hidden.png>hoge-big.jpeg\n'+
             '---foo-hidden-small.gif|^_^a.bmp\n'+
             '--hiddena-hoge.png<=not hidden~~\n'+
             '--small.jpg<=not small(^_^)\n'+
             'normal-small-big.hoge')));

sub print_image_spec {
    $_ = $_[0];
    while(my($name, $hidden, $size, $ext, $rest) = /([A-Za-z]+)(-hidden)?(?:-(small|big))?\.([A-Za-z]+)/) {
        printf("name:'%s', ext:'%s', size: %s hidden: %s\n",
               $name, $ext, $size||'normal', $hidden ? 'True' : 'False');
        $_ = $';
    }
}

(defun print-image-spec (str)
  (ppcre:regex-replace-all "([A-Za-z]+)(-hidden)?(?:-(small|big))?\\.([A-Za-z]+)" str
                           (lambda (m name hidden size ext)
                                   (format t "name:'~a', ext:'~a', size: ~a hidden: ~a~%"
                                           name ext
                                           (if (zerop (length size)) "normal" size)
                                           (if hidden "True" "False"))
                                   m)
                           :simple-calls t))

(require 'cl)
(defun print-image-spec-on-buffer ()
  (interactive)
  (save-excursion
    (goto-char (point-min))
    (with-output-to-temp-buffer "*image-spec*"
      (while (re-search-forward "\\([A-Za-z]+\\)\\(-hidden\\)?\\(-\\(small\\|big\\)\\)?\\.\\([A-Za-z]+\\)" nil t)
        (destructuring-bind (s0 e0  sname ename  shidden ehidden _ _ ssize esize  sext eext)
            (match-data)
         (princ (format "name:'%s', ext:'%s', size: %s hidden: %s\n"
                        (buffer-substring sname ename)
                        (buffer-substring sext eext)
                        (if ssize (buffer-substring ssize esize) "normal")
                        (if shidden "True" "False"))))))))

class ExtendedString(self:String) {
  import java.util.regex._
  def regexEach[A](reg:String)(f:(Matcher)=>A) = {
    val m = Pattern.compile(reg).matcher(self)
    while(m.find) {f(m)}
  }
}
implicit def string2ext(self:String) = new ExtendedString(self);

"""
aaa abc-hidden.png>hoge-big.jpeg
---foo-hidden-small.gif|^_^a.bmp
--hiddena-hoge.png<=not hidden~~
--small.jpg<=not small(^_^)
normal-small-big.hoge
""".trim.regexEach("([a-zA-Z]+)(-hidden)?(?:-(small|big))?\\.([a-zA-Z]+)"){ m =>
  println("name: '"+m.group(1)+"', ext: '"+m.group(4)+
          "', size: "+(if(m.group(3)==null){"normal"}else{m.group(3)}) + 
          ", hidden: "+(if(m.group(2)==null){"False"}else{"True"}))
}

module Main where

import System
import Char
import Text.ParserCombinators.Parsec hiding (spaces)
import Monad
import Control.Monad.Error
import IO hiding (try)

main = readFile "a.txt" >>= pp >>= print >> return ()
pp s = case parse (many $try(wordx)<|>other) "lisp" s of
         (Right x) -> return $filter okparse x
         (Left x)  -> error "error"
okparse ("",_,_,_) = False
okparse  (_,_,_,_)= True
w = many1 letter
hi = do  _ <- char '-'
         x <- string "hidden"
         return x
sz = do  _ <- char '-'
         x <- try(string "big") <|> string "small"
         return x

wordx = do x <- w
           (y, z) <- (do yy <-try (hi)
                         zz <-option "" sz
                         return (yy,zz))
                     <|>
                     (do zz<- option "" sz
                         return ("", zz))
           char '.'
           ext <- w
           return (x,y,z, ext)

other = do x <- noneOf ""
           return ("", "","","")

(defun frob (str)
  (let ((l (remove-if-not (lambda (s) (cl-ppcre:scan "\\." s)) (cl-ppcre:split "([^A-z-\\.]|_|\\^)" str))))
    (dolist (item l)
      (destructuring-bind (name prop _ ext)
	  (map 'list #'values
	       (nth-value 1 (cl-ppcre:scan-to-strings "[^A-z]*([A-z]*)((-small|-big|-hidden)*)\\.([A-z]*)" item)))
	(declare (ignore _))
	(format t "name: '~A',~,8@Text: '~A', ~,8@Tsize: ~[Small~;Normal~;Big~], ~,8@THidden: ~:[False~;True~]~%" 
		name ext (big-or-small-or-nomal-p prop) (hiddenp prop))))))

(defun hiddenp (str)
  (if (cl-ppcre:scan "-hidden[\\.-]*" str) t nil))

(defun big-or-small-or-nomal-p (str)
  (cond ((cl-ppcre:scan "-big" str) 2) 
	((cl-ppcre:scan "-small" str) 0)
	('T 1)))

#include <iostream>
#include <string>
#include <algorithm>
#include <functional>
#include <iterator>
#include <ctype.h> // isalpha()

struct is_alpha : public std::unary_function<char, bool>
{
    bool operator()(char c) const
    {
        return isalpha(c);
    }
};

bool option(
    std::string::const_iterator beg,
    std::string::const_iterator& it,
    const std::string& name,
    std::string& ret)
{
    const std::string s = "-" + name;

    if (std::distance(beg, it) >= s.size() && std::equal(it - s.size(), it, s.begin()))
    {
        it -= s.size();

        ret = name;

        return true;
    }
    else
    {
        return false;
    }
}

void extract(const std::string& s)
{
    std::string::const_iterator it = s.begin();

    while ((it = std::find(it, s.end(), '.')) != s.end())
    {
        std::string::const_iterator it2;

        it2 = std::find_if(it + 1, s.end(), std::not1(is_alpha()));

        const std::string ext(it + 1, it2);

        std::string size, hidden;

        it2 = it;

        option(s.begin(), it2, "big", size) || option(s.begin(), it2, "small", size);

        option(s.begin(), it2, "hidden", hidden);

        std::string name(
            std::find_if(
                std::string::const_reverse_iterator(it2),
                s.rend(),
                std::not1(is_alpha())
            ).base(), it2
        );

        if (name.empty())
        {
            if (!hidden.empty())
            {
                name.swap(hidden);
            }
            else if (!size.empty())
            {
                name.swap(size);
            }
        }

        if (size.empty())
        {
            size = "normal";
        }

        std::cout
            << "name:'" << name << "', "
            << "ext:'" << ext << "', "
            << "size: " << size << " "
            << "hidden: " << (!hidden.empty())
            << std::endl;

        ++it;
    }
}

int main()
{
    std::boolalpha(std::cout);

    extract(
        "aaa abc-hidden.png>hoge-big.jpeg\n"
        "---foo-hidden-small.gif|^_^a.bmp\n"
        "--hiddena-hoge.png<=not hidden~~\n"
        "--small.jpg<=not small(^_^)\n"
        "normal-small-big.hoge\n"
    );
}

<?php
$str='aaa abc-hidden.png>hoge-big.jpeg
---foo-hidden-small.gif|^_^a.bmp
--hiddena-hoge.png<=not hidden~~
--small.jpg<=not small(^_^)
normal-small-big.hoge';

$matches=array();
preg_match_all('/([a-zA-Z]+)(-hidden|)(-(small|big)|)\.([a-zA-Z]+)/', $str, $matches, PREG_SET_ORDER );

while(list(,$v)=each($matches))
{	$hd=$v[2]?"True":"False";
	$sz=$v[4]?$v[4]:"normal";
	echo "name:'${v[1]}', ext:'${v[5]}', size: $sz hidden: $hd\n";
}
?>

| in delimiters candidates |
in := 'aaa abc-hidden.png>hoge-big.jpeg
---foo-hidden-small.gif|^_^a.bmp
--hiddena-hoge.png<=not hidden~~
--small.jpg<=not small(^_^)
normal-small-big.hoge'.

delimiters := in asSet reject: [:each | each isLetter or: ['-.' includes: each]].
candidates := (in findTokens: delimiters) reject: [:each | each = each sansPeriodSuffix].
World findATranscript: nil.
candidates do: [:cand |
	| strm next ext size hidden |
	strm := (cand findTokens: '-.') reversed readStream.
	ext := strm next.
	next := strm next.
	(strm peek notNil and: [#(small big) includes: next])
		ifTrue: [size := next. next := strm next] ifFalse: [size := 'normal'].
	(hidden := strm peek notNil and: [next = #hidden])
		ifTrue: [next := strm next].
	Transcript cr; show: {#name->next. #ext->ext. #size->size. #hidden->hidden}]

sub print_image_spec {
    my $str = shift;
    while ( $str =~ /(?<name>[A-Za-z]+)(?<hidden>-hidden)?(?:-(?<size>small|big))?\.(?<ext>[A-Za-z]+)/g ) {
        printf(
            "name:'%s', ext:'%s', size: %s hidden: %s\n",
            $+{name}, $+{ext},
            $+{size} || 'normal',
            $+{hidden} ? 'True' : 'False'
        );
    }
}

{
	s = $0
	while (match(s,/[a-z]+(-hidden)?(-small|-big)?\.[a-z]+/)) {
		matched = substr(s,RSTART,RLENGTH)
		s = substr(s,RSTART+RLENGTH+1)

		hyphen = index(matched,"-")
		period = index(matched,".")

		if (hyphen > 0) {
			name = substr(matched, 1, hyphen-1)
			extra = substr(matched, hyphen, period - hyphen)
			hidden = (extra ~ /-hidden/) ? "True" : "False"
			if (extra ~ /-small/) size = "small"
			else if (extra ~ /-big/) size = "big"
			else size = "normal"
			ext = substr(matched, period+1)
		} else {
			name = substr(matched, 1, period-1)
			hidden = "False"
			size = "normal"
			ext = substr(matched, period+1)
		}
		printf("name:'%s', ext:'%s', size: %s hidden: %s\n", name, ext, size, hidden)
	}
}