Quelle pipeobj.g Sprache: unbekannt

###########################################################################
##
#W  pipeobj.g           OpenMath Package                     Andrew Solomon
#W                                                         Marco Costantini
##
#Y    Copyright (C) 1999, 2000, 2001, 2006
#Y    School Math and Comp. Sci., University of St.  Andrews, Scotland
#Y    Copyright (C) 2004, 2005, 2006 Marco Costantini
##
##  Pipe exactly one OpenMath object from <input stream> to
##  <output string>.
##

###########################################################################
##
#F  ReadCharSkipSpace( <input> )
##
##  Reads and returns next non-space byte from input stream
##  returning the associated character.
##
BindGlobal("ReadCharSkipSpace", function(input)
local
  b, # byte
  c;  # character

b :=  ReadByte(input);
while b <> fail and (CHAR_INT(b) in [' ','\n','\t','\r']) do
   b := ReadByte(input);
od;
if b <> fail then
  return CHAR_INT(b);
fi;

return fail;
end);

###########################################################################
##
#F  ReadChar( <input> )
##
##  Reads and returns next byte as a character.
##
BindGlobal("ReadChar", function(input)
local
  b, # byte
  c;  # character

b :=  ReadByte(input);
if b <> fail then
  return CHAR_INT(b);
fi;

return fail;
end);

###########################################################################
##
#F  CharIsSpace( <c> )
##
##  True iff c is a space, newline or tabstop.
##
BindGlobal("CharIsSpace", c -> c in  [' ','\n','\t']);

###########################################################################
##
#F  ReadTag( <input>, <firstbyte> )
##
##  Read a tag of the form < tag >
##  return "<tag>" - no spaces
##
BindGlobal("ReadTag", function(input,firstbyte)
local
  s, # the string to return
  c,  # the character read
  d; # string to discard: contains encode or comment

s := "";
# find the first '<'
    if CHAR_INT(firstbyte) in [' ','\n','\t','\r'] then
  c := ReadCharSkipSpace(input);
else
     c := CHAR_INT(firstbyte);
fi;

    if c <> '<' then
    return fail;
fi;

s[1] := c;
c := ReadCharSkipSpace(input);

# code inserted later to ensure encoding node (i.e <? ... ?>) is ignored
# ignore also things like 
if c = '?' or c = '!'  then

        d := "";
        repeat
            c := ReadChar( input );
            if c = fail  then
                return fail;
            fi;
            Add( d, c );
        until Length( d ) >= 2 and d{[ Length( d ) - 1 .. Length( d ) ]} = "?>"
          or Length( d ) >= 3 and d{[ Length( d ) - 2 .. Length( d ) ]} = "-->";

  # now find the real beginning of the tag
  s := "";
  c := ReadCharSkipSpace(input);
  if c <> '<' then
   return fail;
  fi;

  s[1] := c;
  c := ReadCharSkipSpace(input);
fi;

    repeat
        if c = fail  then
            return fail;
        fi;
        Add( s, c );
        c := ReadChar( input );
    until c = '>';
    while CharIsSpace( s[Length(s)] ) do
        Unbind( s[Length(s)] );
    od;
    Add( s, c );
    return s;

end);

###########################################################################
##
#F  PipeOpenMathObject( <input>, <output>, <firstbyte> )
##
##  Return "true" if we succeed in piping an OMOBJ from
##  input to output, fail otherwise.
##
##  Based on a very complicated finite state automaton
##  which accepts "<OMOBJ>" then any amount of stuff
##  and terminates with "<\OMOBJ>" unless it is inside
##  a comment "".
##
BindGlobal("PipeOpenMathObject", function(input,output,firstbyte)

local
  s, # string
  EndOMOBJstates, # list of states all of which behave almost the same way
  state, # current state
  nextchar, # the next character we expect
  c; # the last character read

# first read " <OMOBJ >"
s  := ReadTag(input,firstbyte);

if not (IsList( s ) and Length( s ) > 6 and s{[ 1 .. 6 ]} = "<OMOBJ")  then
  return fail;
fi;
Append( output, s );

EndOMOBJstates:= ["InXMLRead</","InXMLRead</O","InXMLRead</OM",
  "InXMLRead</OMO","InXMLRead</OMOB","InXMLRead</OMOBJ"];

# start state
state := "InXML";

c := ReadChar(input);
while c <> fail do

  ## Start state
  if state =  "InXML" then
   if c = '<' then
    state := "InXMLRead<";
   fi;

  ## Read a `<`
  elif state = "InXMLRead<" then
   if c = '!' then
    state := "InXMLRead<!";
   elif c = '/' then
    state := "InXMLRead</";
   elif c <> '<' then # if c = '<' then we stay in this state
    state := "InXML";
   fi;

  ## Read some part of InXMLRead</OMOBJ
  ## these states are all dealt with together
  elif state in  EndOMOBJstates then
   if state <> EndOMOBJstates[Length(EndOMOBJstates)] then # this isn't the last one
    nextchar := EndOMOBJstates[Length(EndOMOBJstates)][Length(state)+1];
   else
    nextchar := '>';
    # skip to next nonblank
    while c <> fail and CharIsSpace(c) do
     Append(output, [c]);
     c := ReadChar(input);
    od;
    if c = fail then
     return fail;
    elif c = nextchar then
     Append(output, [c]);
     return true;
    fi;
   fi;

   if c = nextchar then
    state := Concatenation(state, [nextchar]);
   elif c = '<' then
    state := "InXMLRead<";
   else
    state := "InXML";
   fi;

  ## now on to the comments
  elif state = "InXMLRead<!" then
   if c = '-' then
    state := "InXMLRead<!-";
   elif c = '<' then
    state := "InXMLRead<";
   else
    state := "InXML";
   fi;

  elif state = "InXMLRead<!-" then
   if c = '-' then
    state := "InComment";
   elif c = '<' then
    state := "InXMLRead<";
   else
    state := "InXML";
   fi;

  elif state = "InComment" then
   if c = '-' then
    state := "InComment-";
   fi;

  elif state = "InComment-" then
   if c = '-' then
    state := "InComment--";
   else
    state := "InComment";
   fi;

  elif state = "InComment--" then
   if c = '>' then
    state := "InXML";
   else
    state := "InComment";
   fi;

  else
   Error("Invalid state:",state);
  fi;

  # finally send the character off to the output and get the next one

  Append(output, [c]);
  c := ReadChar(input);
od;
return fail;
end);

###########################################################################
#E

Quelle pipeobj.g Sprache: unbekannt

[ Dauer der Verarbeitung: 0.28 Sekunden (vorverarbeitet) ]